001    /**
002     * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.service.persistence;
016    
017    import com.liferay.portal.NoSuchMembershipRequestException;
018    import com.liferay.portal.NoSuchModelException;
019    import com.liferay.portal.kernel.annotation.BeanReference;
020    import com.liferay.portal.kernel.cache.CacheRegistryUtil;
021    import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
022    import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
023    import com.liferay.portal.kernel.dao.orm.FinderPath;
024    import com.liferay.portal.kernel.dao.orm.Query;
025    import com.liferay.portal.kernel.dao.orm.QueryPos;
026    import com.liferay.portal.kernel.dao.orm.QueryUtil;
027    import com.liferay.portal.kernel.dao.orm.Session;
028    import com.liferay.portal.kernel.exception.SystemException;
029    import com.liferay.portal.kernel.log.Log;
030    import com.liferay.portal.kernel.log.LogFactoryUtil;
031    import com.liferay.portal.kernel.util.GetterUtil;
032    import com.liferay.portal.kernel.util.InstanceFactory;
033    import com.liferay.portal.kernel.util.OrderByComparator;
034    import com.liferay.portal.kernel.util.StringBundler;
035    import com.liferay.portal.kernel.util.StringPool;
036    import com.liferay.portal.kernel.util.StringUtil;
037    import com.liferay.portal.model.MembershipRequest;
038    import com.liferay.portal.model.ModelListener;
039    import com.liferay.portal.model.impl.MembershipRequestImpl;
040    import com.liferay.portal.model.impl.MembershipRequestModelImpl;
041    import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
042    
043    import java.io.Serializable;
044    
045    import java.util.ArrayList;
046    import java.util.Collections;
047    import java.util.List;
048    
049    /**
050     * @author    Brian Wing Shun Chan
051     * @see       MembershipRequestPersistence
052     * @see       MembershipRequestUtil
053     * @generated
054     */
055    public class MembershipRequestPersistenceImpl extends BasePersistenceImpl<MembershipRequest>
056            implements MembershipRequestPersistence {
057            public static final String FINDER_CLASS_NAME_ENTITY = MembershipRequestImpl.class.getName();
058            public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
059                    ".List";
060            public static final FinderPath FINDER_PATH_FIND_BY_GROUPID = new FinderPath(MembershipRequestModelImpl.ENTITY_CACHE_ENABLED,
061                            MembershipRequestModelImpl.FINDER_CACHE_ENABLED,
062                            FINDER_CLASS_NAME_LIST, "findByGroupId",
063                            new String[] {
064                                    Long.class.getName(),
065                                    
066                            "java.lang.Integer", "java.lang.Integer",
067                                    "com.liferay.portal.kernel.util.OrderByComparator"
068                            });
069            public static final FinderPath FINDER_PATH_COUNT_BY_GROUPID = new FinderPath(MembershipRequestModelImpl.ENTITY_CACHE_ENABLED,
070                            MembershipRequestModelImpl.FINDER_CACHE_ENABLED,
071                            FINDER_CLASS_NAME_LIST, "countByGroupId",
072                            new String[] { Long.class.getName() });
073            public static final FinderPath FINDER_PATH_FIND_BY_USERID = new FinderPath(MembershipRequestModelImpl.ENTITY_CACHE_ENABLED,
074                            MembershipRequestModelImpl.FINDER_CACHE_ENABLED,
075                            FINDER_CLASS_NAME_LIST, "findByUserId",
076                            new String[] {
077                                    Long.class.getName(),
078                                    
079                            "java.lang.Integer", "java.lang.Integer",
080                                    "com.liferay.portal.kernel.util.OrderByComparator"
081                            });
082            public static final FinderPath FINDER_PATH_COUNT_BY_USERID = new FinderPath(MembershipRequestModelImpl.ENTITY_CACHE_ENABLED,
083                            MembershipRequestModelImpl.FINDER_CACHE_ENABLED,
084                            FINDER_CLASS_NAME_LIST, "countByUserId",
085                            new String[] { Long.class.getName() });
086            public static final FinderPath FINDER_PATH_FIND_BY_G_S = new FinderPath(MembershipRequestModelImpl.ENTITY_CACHE_ENABLED,
087                            MembershipRequestModelImpl.FINDER_CACHE_ENABLED,
088                            FINDER_CLASS_NAME_LIST, "findByG_S",
089                            new String[] {
090                                    Long.class.getName(), Integer.class.getName(),
091                                    
092                            "java.lang.Integer", "java.lang.Integer",
093                                    "com.liferay.portal.kernel.util.OrderByComparator"
094                            });
095            public static final FinderPath FINDER_PATH_COUNT_BY_G_S = new FinderPath(MembershipRequestModelImpl.ENTITY_CACHE_ENABLED,
096                            MembershipRequestModelImpl.FINDER_CACHE_ENABLED,
097                            FINDER_CLASS_NAME_LIST, "countByG_S",
098                            new String[] { Long.class.getName(), Integer.class.getName() });
099            public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(MembershipRequestModelImpl.ENTITY_CACHE_ENABLED,
100                            MembershipRequestModelImpl.FINDER_CACHE_ENABLED,
101                            FINDER_CLASS_NAME_LIST, "findAll", new String[0]);
102            public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(MembershipRequestModelImpl.ENTITY_CACHE_ENABLED,
103                            MembershipRequestModelImpl.FINDER_CACHE_ENABLED,
104                            FINDER_CLASS_NAME_LIST, "countAll", new String[0]);
105    
106            public void cacheResult(MembershipRequest membershipRequest) {
107                    EntityCacheUtil.putResult(MembershipRequestModelImpl.ENTITY_CACHE_ENABLED,
108                            MembershipRequestImpl.class, membershipRequest.getPrimaryKey(),
109                            membershipRequest);
110            }
111    
112            public void cacheResult(List<MembershipRequest> membershipRequests) {
113                    for (MembershipRequest membershipRequest : membershipRequests) {
114                            if (EntityCacheUtil.getResult(
115                                                    MembershipRequestModelImpl.ENTITY_CACHE_ENABLED,
116                                                    MembershipRequestImpl.class,
117                                                    membershipRequest.getPrimaryKey(), this) == null) {
118                                    cacheResult(membershipRequest);
119                            }
120                    }
121            }
122    
123            public void clearCache() {
124                    CacheRegistryUtil.clear(MembershipRequestImpl.class.getName());
125                    EntityCacheUtil.clearCache(MembershipRequestImpl.class.getName());
126                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
127                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
128            }
129    
130            public void clearCache(MembershipRequest membershipRequest) {
131                    EntityCacheUtil.removeResult(MembershipRequestModelImpl.ENTITY_CACHE_ENABLED,
132                            MembershipRequestImpl.class, membershipRequest.getPrimaryKey());
133            }
134    
135            public MembershipRequest create(long membershipRequestId) {
136                    MembershipRequest membershipRequest = new MembershipRequestImpl();
137    
138                    membershipRequest.setNew(true);
139                    membershipRequest.setPrimaryKey(membershipRequestId);
140    
141                    return membershipRequest;
142            }
143    
144            public MembershipRequest remove(Serializable primaryKey)
145                    throws NoSuchModelException, SystemException {
146                    return remove(((Long)primaryKey).longValue());
147            }
148    
149            public MembershipRequest remove(long membershipRequestId)
150                    throws NoSuchMembershipRequestException, SystemException {
151                    Session session = null;
152    
153                    try {
154                            session = openSession();
155    
156                            MembershipRequest membershipRequest = (MembershipRequest)session.get(MembershipRequestImpl.class,
157                                            new Long(membershipRequestId));
158    
159                            if (membershipRequest == null) {
160                                    if (_log.isWarnEnabled()) {
161                                            _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
162                                                    membershipRequestId);
163                                    }
164    
165                                    throw new NoSuchMembershipRequestException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
166                                            membershipRequestId);
167                            }
168    
169                            return remove(membershipRequest);
170                    }
171                    catch (NoSuchMembershipRequestException nsee) {
172                            throw nsee;
173                    }
174                    catch (Exception e) {
175                            throw processException(e);
176                    }
177                    finally {
178                            closeSession(session);
179                    }
180            }
181    
182            protected MembershipRequest removeImpl(MembershipRequest membershipRequest)
183                    throws SystemException {
184                    membershipRequest = toUnwrappedModel(membershipRequest);
185    
186                    Session session = null;
187    
188                    try {
189                            session = openSession();
190    
191                            if (membershipRequest.isCachedModel() ||
192                                            BatchSessionUtil.isEnabled()) {
193                                    Object staleObject = session.get(MembershipRequestImpl.class,
194                                                    membershipRequest.getPrimaryKeyObj());
195    
196                                    if (staleObject != null) {
197                                            session.evict(staleObject);
198                                    }
199                            }
200    
201                            session.delete(membershipRequest);
202    
203                            session.flush();
204                    }
205                    catch (Exception e) {
206                            throw processException(e);
207                    }
208                    finally {
209                            closeSession(session);
210                    }
211    
212                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
213    
214                    EntityCacheUtil.removeResult(MembershipRequestModelImpl.ENTITY_CACHE_ENABLED,
215                            MembershipRequestImpl.class, membershipRequest.getPrimaryKey());
216    
217                    return membershipRequest;
218            }
219    
220            public MembershipRequest updateImpl(
221                    com.liferay.portal.model.MembershipRequest membershipRequest,
222                    boolean merge) throws SystemException {
223                    membershipRequest = toUnwrappedModel(membershipRequest);
224    
225                    Session session = null;
226    
227                    try {
228                            session = openSession();
229    
230                            BatchSessionUtil.update(session, membershipRequest, merge);
231    
232                            membershipRequest.setNew(false);
233                    }
234                    catch (Exception e) {
235                            throw processException(e);
236                    }
237                    finally {
238                            closeSession(session);
239                    }
240    
241                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
242    
243                    EntityCacheUtil.putResult(MembershipRequestModelImpl.ENTITY_CACHE_ENABLED,
244                            MembershipRequestImpl.class, membershipRequest.getPrimaryKey(),
245                            membershipRequest);
246    
247                    return membershipRequest;
248            }
249    
250            protected MembershipRequest toUnwrappedModel(
251                    MembershipRequest membershipRequest) {
252                    if (membershipRequest instanceof MembershipRequestImpl) {
253                            return membershipRequest;
254                    }
255    
256                    MembershipRequestImpl membershipRequestImpl = new MembershipRequestImpl();
257    
258                    membershipRequestImpl.setNew(membershipRequest.isNew());
259                    membershipRequestImpl.setPrimaryKey(membershipRequest.getPrimaryKey());
260    
261                    membershipRequestImpl.setMembershipRequestId(membershipRequest.getMembershipRequestId());
262                    membershipRequestImpl.setCompanyId(membershipRequest.getCompanyId());
263                    membershipRequestImpl.setUserId(membershipRequest.getUserId());
264                    membershipRequestImpl.setCreateDate(membershipRequest.getCreateDate());
265                    membershipRequestImpl.setGroupId(membershipRequest.getGroupId());
266                    membershipRequestImpl.setComments(membershipRequest.getComments());
267                    membershipRequestImpl.setReplyComments(membershipRequest.getReplyComments());
268                    membershipRequestImpl.setReplyDate(membershipRequest.getReplyDate());
269                    membershipRequestImpl.setReplierUserId(membershipRequest.getReplierUserId());
270                    membershipRequestImpl.setStatusId(membershipRequest.getStatusId());
271    
272                    return membershipRequestImpl;
273            }
274    
275            public MembershipRequest findByPrimaryKey(Serializable primaryKey)
276                    throws NoSuchModelException, SystemException {
277                    return findByPrimaryKey(((Long)primaryKey).longValue());
278            }
279    
280            public MembershipRequest findByPrimaryKey(long membershipRequestId)
281                    throws NoSuchMembershipRequestException, SystemException {
282                    MembershipRequest membershipRequest = fetchByPrimaryKey(membershipRequestId);
283    
284                    if (membershipRequest == null) {
285                            if (_log.isWarnEnabled()) {
286                                    _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
287                                            membershipRequestId);
288                            }
289    
290                            throw new NoSuchMembershipRequestException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
291                                    membershipRequestId);
292                    }
293    
294                    return membershipRequest;
295            }
296    
297            public MembershipRequest fetchByPrimaryKey(Serializable primaryKey)
298                    throws SystemException {
299                    return fetchByPrimaryKey(((Long)primaryKey).longValue());
300            }
301    
302            public MembershipRequest fetchByPrimaryKey(long membershipRequestId)
303                    throws SystemException {
304                    MembershipRequest membershipRequest = (MembershipRequest)EntityCacheUtil.getResult(MembershipRequestModelImpl.ENTITY_CACHE_ENABLED,
305                                    MembershipRequestImpl.class, membershipRequestId, this);
306    
307                    if (membershipRequest == null) {
308                            Session session = null;
309    
310                            try {
311                                    session = openSession();
312    
313                                    membershipRequest = (MembershipRequest)session.get(MembershipRequestImpl.class,
314                                                    new Long(membershipRequestId));
315                            }
316                            catch (Exception e) {
317                                    throw processException(e);
318                            }
319                            finally {
320                                    if (membershipRequest != null) {
321                                            cacheResult(membershipRequest);
322                                    }
323    
324                                    closeSession(session);
325                            }
326                    }
327    
328                    return membershipRequest;
329            }
330    
331            public List<MembershipRequest> findByGroupId(long groupId)
332                    throws SystemException {
333                    return findByGroupId(groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
334            }
335    
336            public List<MembershipRequest> findByGroupId(long groupId, int start,
337                    int end) throws SystemException {
338                    return findByGroupId(groupId, start, end, null);
339            }
340    
341            public List<MembershipRequest> findByGroupId(long groupId, int start,
342                    int end, OrderByComparator orderByComparator) throws SystemException {
343                    Object[] finderArgs = new Object[] {
344                                    groupId,
345                                    
346                                    String.valueOf(start), String.valueOf(end),
347                                    String.valueOf(orderByComparator)
348                            };
349    
350                    List<MembershipRequest> list = (List<MembershipRequest>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_GROUPID,
351                                    finderArgs, this);
352    
353                    if (list == null) {
354                            Session session = null;
355    
356                            try {
357                                    session = openSession();
358    
359                                    StringBundler query = null;
360    
361                                    if (orderByComparator != null) {
362                                            query = new StringBundler(3 +
363                                                            (orderByComparator.getOrderByFields().length * 3));
364                                    }
365                                    else {
366                                            query = new StringBundler(3);
367                                    }
368    
369                                    query.append(_SQL_SELECT_MEMBERSHIPREQUEST_WHERE);
370    
371                                    query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
372    
373                                    if (orderByComparator != null) {
374                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
375                                                    orderByComparator);
376                                    }
377    
378                                    else {
379                                            query.append(MembershipRequestModelImpl.ORDER_BY_JPQL);
380                                    }
381    
382                                    String sql = query.toString();
383    
384                                    Query q = session.createQuery(sql);
385    
386                                    QueryPos qPos = QueryPos.getInstance(q);
387    
388                                    qPos.add(groupId);
389    
390                                    list = (List<MembershipRequest>)QueryUtil.list(q, getDialect(),
391                                                    start, end);
392                            }
393                            catch (Exception e) {
394                                    throw processException(e);
395                            }
396                            finally {
397                                    if (list == null) {
398                                            list = new ArrayList<MembershipRequest>();
399                                    }
400    
401                                    cacheResult(list);
402    
403                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_GROUPID,
404                                            finderArgs, list);
405    
406                                    closeSession(session);
407                            }
408                    }
409    
410                    return list;
411            }
412    
413            public MembershipRequest findByGroupId_First(long groupId,
414                    OrderByComparator orderByComparator)
415                    throws NoSuchMembershipRequestException, SystemException {
416                    List<MembershipRequest> list = findByGroupId(groupId, 0, 1,
417                                    orderByComparator);
418    
419                    if (list.isEmpty()) {
420                            StringBundler msg = new StringBundler(4);
421    
422                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
423    
424                            msg.append("groupId=");
425                            msg.append(groupId);
426    
427                            msg.append(StringPool.CLOSE_CURLY_BRACE);
428    
429                            throw new NoSuchMembershipRequestException(msg.toString());
430                    }
431                    else {
432                            return list.get(0);
433                    }
434            }
435    
436            public MembershipRequest findByGroupId_Last(long groupId,
437                    OrderByComparator orderByComparator)
438                    throws NoSuchMembershipRequestException, SystemException {
439                    int count = countByGroupId(groupId);
440    
441                    List<MembershipRequest> list = findByGroupId(groupId, count - 1, count,
442                                    orderByComparator);
443    
444                    if (list.isEmpty()) {
445                            StringBundler msg = new StringBundler(4);
446    
447                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
448    
449                            msg.append("groupId=");
450                            msg.append(groupId);
451    
452                            msg.append(StringPool.CLOSE_CURLY_BRACE);
453    
454                            throw new NoSuchMembershipRequestException(msg.toString());
455                    }
456                    else {
457                            return list.get(0);
458                    }
459            }
460    
461            public MembershipRequest[] findByGroupId_PrevAndNext(
462                    long membershipRequestId, long groupId,
463                    OrderByComparator orderByComparator)
464                    throws NoSuchMembershipRequestException, SystemException {
465                    MembershipRequest membershipRequest = findByPrimaryKey(membershipRequestId);
466    
467                    Session session = null;
468    
469                    try {
470                            session = openSession();
471    
472                            MembershipRequest[] array = new MembershipRequestImpl[3];
473    
474                            array[0] = getByGroupId_PrevAndNext(session, membershipRequest,
475                                            groupId, orderByComparator, true);
476    
477                            array[1] = membershipRequest;
478    
479                            array[2] = getByGroupId_PrevAndNext(session, membershipRequest,
480                                            groupId, orderByComparator, false);
481    
482                            return array;
483                    }
484                    catch (Exception e) {
485                            throw processException(e);
486                    }
487                    finally {
488                            closeSession(session);
489                    }
490            }
491    
492            protected MembershipRequest getByGroupId_PrevAndNext(Session session,
493                    MembershipRequest membershipRequest, long groupId,
494                    OrderByComparator orderByComparator, boolean previous) {
495                    StringBundler query = null;
496    
497                    if (orderByComparator != null) {
498                            query = new StringBundler(6 +
499                                            (orderByComparator.getOrderByFields().length * 6));
500                    }
501                    else {
502                            query = new StringBundler(3);
503                    }
504    
505                    query.append(_SQL_SELECT_MEMBERSHIPREQUEST_WHERE);
506    
507                    query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
508    
509                    if (orderByComparator != null) {
510                            String[] orderByFields = orderByComparator.getOrderByFields();
511    
512                            if (orderByFields.length > 0) {
513                                    query.append(WHERE_AND);
514                            }
515    
516                            for (int i = 0; i < orderByFields.length; i++) {
517                                    query.append(_ORDER_BY_ENTITY_ALIAS);
518                                    query.append(orderByFields[i]);
519    
520                                    if ((i + 1) < orderByFields.length) {
521                                            if (orderByComparator.isAscending() ^ previous) {
522                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
523                                            }
524                                            else {
525                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
526                                            }
527                                    }
528                                    else {
529                                            if (orderByComparator.isAscending() ^ previous) {
530                                                    query.append(WHERE_GREATER_THAN);
531                                            }
532                                            else {
533                                                    query.append(WHERE_LESSER_THAN);
534                                            }
535                                    }
536                            }
537    
538                            query.append(ORDER_BY_CLAUSE);
539    
540                            for (int i = 0; i < orderByFields.length; i++) {
541                                    query.append(_ORDER_BY_ENTITY_ALIAS);
542                                    query.append(orderByFields[i]);
543    
544                                    if ((i + 1) < orderByFields.length) {
545                                            if (orderByComparator.isAscending() ^ previous) {
546                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
547                                            }
548                                            else {
549                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
550                                            }
551                                    }
552                                    else {
553                                            if (orderByComparator.isAscending() ^ previous) {
554                                                    query.append(ORDER_BY_ASC);
555                                            }
556                                            else {
557                                                    query.append(ORDER_BY_DESC);
558                                            }
559                                    }
560                            }
561                    }
562    
563                    else {
564                            query.append(MembershipRequestModelImpl.ORDER_BY_JPQL);
565                    }
566    
567                    String sql = query.toString();
568    
569                    Query q = session.createQuery(sql);
570    
571                    q.setFirstResult(0);
572                    q.setMaxResults(2);
573    
574                    QueryPos qPos = QueryPos.getInstance(q);
575    
576                    qPos.add(groupId);
577    
578                    if (orderByComparator != null) {
579                            Object[] values = orderByComparator.getOrderByValues(membershipRequest);
580    
581                            for (Object value : values) {
582                                    qPos.add(value);
583                            }
584                    }
585    
586                    List<MembershipRequest> list = q.list();
587    
588                    if (list.size() == 2) {
589                            return list.get(1);
590                    }
591                    else {
592                            return null;
593                    }
594            }
595    
596            public List<MembershipRequest> findByUserId(long userId)
597                    throws SystemException {
598                    return findByUserId(userId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
599            }
600    
601            public List<MembershipRequest> findByUserId(long userId, int start, int end)
602                    throws SystemException {
603                    return findByUserId(userId, start, end, null);
604            }
605    
606            public List<MembershipRequest> findByUserId(long userId, int start,
607                    int end, OrderByComparator orderByComparator) throws SystemException {
608                    Object[] finderArgs = new Object[] {
609                                    userId,
610                                    
611                                    String.valueOf(start), String.valueOf(end),
612                                    String.valueOf(orderByComparator)
613                            };
614    
615                    List<MembershipRequest> list = (List<MembershipRequest>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_USERID,
616                                    finderArgs, this);
617    
618                    if (list == null) {
619                            Session session = null;
620    
621                            try {
622                                    session = openSession();
623    
624                                    StringBundler query = null;
625    
626                                    if (orderByComparator != null) {
627                                            query = new StringBundler(3 +
628                                                            (orderByComparator.getOrderByFields().length * 3));
629                                    }
630                                    else {
631                                            query = new StringBundler(3);
632                                    }
633    
634                                    query.append(_SQL_SELECT_MEMBERSHIPREQUEST_WHERE);
635    
636                                    query.append(_FINDER_COLUMN_USERID_USERID_2);
637    
638                                    if (orderByComparator != null) {
639                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
640                                                    orderByComparator);
641                                    }
642    
643                                    else {
644                                            query.append(MembershipRequestModelImpl.ORDER_BY_JPQL);
645                                    }
646    
647                                    String sql = query.toString();
648    
649                                    Query q = session.createQuery(sql);
650    
651                                    QueryPos qPos = QueryPos.getInstance(q);
652    
653                                    qPos.add(userId);
654    
655                                    list = (List<MembershipRequest>)QueryUtil.list(q, getDialect(),
656                                                    start, end);
657                            }
658                            catch (Exception e) {
659                                    throw processException(e);
660                            }
661                            finally {
662                                    if (list == null) {
663                                            list = new ArrayList<MembershipRequest>();
664                                    }
665    
666                                    cacheResult(list);
667    
668                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_USERID,
669                                            finderArgs, list);
670    
671                                    closeSession(session);
672                            }
673                    }
674    
675                    return list;
676            }
677    
678            public MembershipRequest findByUserId_First(long userId,
679                    OrderByComparator orderByComparator)
680                    throws NoSuchMembershipRequestException, SystemException {
681                    List<MembershipRequest> list = findByUserId(userId, 0, 1,
682                                    orderByComparator);
683    
684                    if (list.isEmpty()) {
685                            StringBundler msg = new StringBundler(4);
686    
687                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
688    
689                            msg.append("userId=");
690                            msg.append(userId);
691    
692                            msg.append(StringPool.CLOSE_CURLY_BRACE);
693    
694                            throw new NoSuchMembershipRequestException(msg.toString());
695                    }
696                    else {
697                            return list.get(0);
698                    }
699            }
700    
701            public MembershipRequest findByUserId_Last(long userId,
702                    OrderByComparator orderByComparator)
703                    throws NoSuchMembershipRequestException, SystemException {
704                    int count = countByUserId(userId);
705    
706                    List<MembershipRequest> list = findByUserId(userId, count - 1, count,
707                                    orderByComparator);
708    
709                    if (list.isEmpty()) {
710                            StringBundler msg = new StringBundler(4);
711    
712                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
713    
714                            msg.append("userId=");
715                            msg.append(userId);
716    
717                            msg.append(StringPool.CLOSE_CURLY_BRACE);
718    
719                            throw new NoSuchMembershipRequestException(msg.toString());
720                    }
721                    else {
722                            return list.get(0);
723                    }
724            }
725    
726            public MembershipRequest[] findByUserId_PrevAndNext(
727                    long membershipRequestId, long userId,
728                    OrderByComparator orderByComparator)
729                    throws NoSuchMembershipRequestException, SystemException {
730                    MembershipRequest membershipRequest = findByPrimaryKey(membershipRequestId);
731    
732                    Session session = null;
733    
734                    try {
735                            session = openSession();
736    
737                            MembershipRequest[] array = new MembershipRequestImpl[3];
738    
739                            array[0] = getByUserId_PrevAndNext(session, membershipRequest,
740                                            userId, orderByComparator, true);
741    
742                            array[1] = membershipRequest;
743    
744                            array[2] = getByUserId_PrevAndNext(session, membershipRequest,
745                                            userId, orderByComparator, false);
746    
747                            return array;
748                    }
749                    catch (Exception e) {
750                            throw processException(e);
751                    }
752                    finally {
753                            closeSession(session);
754                    }
755            }
756    
757            protected MembershipRequest getByUserId_PrevAndNext(Session session,
758                    MembershipRequest membershipRequest, long userId,
759                    OrderByComparator orderByComparator, boolean previous) {
760                    StringBundler query = null;
761    
762                    if (orderByComparator != null) {
763                            query = new StringBundler(6 +
764                                            (orderByComparator.getOrderByFields().length * 6));
765                    }
766                    else {
767                            query = new StringBundler(3);
768                    }
769    
770                    query.append(_SQL_SELECT_MEMBERSHIPREQUEST_WHERE);
771    
772                    query.append(_FINDER_COLUMN_USERID_USERID_2);
773    
774                    if (orderByComparator != null) {
775                            String[] orderByFields = orderByComparator.getOrderByFields();
776    
777                            if (orderByFields.length > 0) {
778                                    query.append(WHERE_AND);
779                            }
780    
781                            for (int i = 0; i < orderByFields.length; i++) {
782                                    query.append(_ORDER_BY_ENTITY_ALIAS);
783                                    query.append(orderByFields[i]);
784    
785                                    if ((i + 1) < orderByFields.length) {
786                                            if (orderByComparator.isAscending() ^ previous) {
787                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
788                                            }
789                                            else {
790                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
791                                            }
792                                    }
793                                    else {
794                                            if (orderByComparator.isAscending() ^ previous) {
795                                                    query.append(WHERE_GREATER_THAN);
796                                            }
797                                            else {
798                                                    query.append(WHERE_LESSER_THAN);
799                                            }
800                                    }
801                            }
802    
803                            query.append(ORDER_BY_CLAUSE);
804    
805                            for (int i = 0; i < orderByFields.length; i++) {
806                                    query.append(_ORDER_BY_ENTITY_ALIAS);
807                                    query.append(orderByFields[i]);
808    
809                                    if ((i + 1) < orderByFields.length) {
810                                            if (orderByComparator.isAscending() ^ previous) {
811                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
812                                            }
813                                            else {
814                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
815                                            }
816                                    }
817                                    else {
818                                            if (orderByComparator.isAscending() ^ previous) {
819                                                    query.append(ORDER_BY_ASC);
820                                            }
821                                            else {
822                                                    query.append(ORDER_BY_DESC);
823                                            }
824                                    }
825                            }
826                    }
827    
828                    else {
829                            query.append(MembershipRequestModelImpl.ORDER_BY_JPQL);
830                    }
831    
832                    String sql = query.toString();
833    
834                    Query q = session.createQuery(sql);
835    
836                    q.setFirstResult(0);
837                    q.setMaxResults(2);
838    
839                    QueryPos qPos = QueryPos.getInstance(q);
840    
841                    qPos.add(userId);
842    
843                    if (orderByComparator != null) {
844                            Object[] values = orderByComparator.getOrderByValues(membershipRequest);
845    
846                            for (Object value : values) {
847                                    qPos.add(value);
848                            }
849                    }
850    
851                    List<MembershipRequest> list = q.list();
852    
853                    if (list.size() == 2) {
854                            return list.get(1);
855                    }
856                    else {
857                            return null;
858                    }
859            }
860    
861            public List<MembershipRequest> findByG_S(long groupId, int statusId)
862                    throws SystemException {
863                    return findByG_S(groupId, statusId, QueryUtil.ALL_POS,
864                            QueryUtil.ALL_POS, null);
865            }
866    
867            public List<MembershipRequest> findByG_S(long groupId, int statusId,
868                    int start, int end) throws SystemException {
869                    return findByG_S(groupId, statusId, start, end, null);
870            }
871    
872            public List<MembershipRequest> findByG_S(long groupId, int statusId,
873                    int start, int end, OrderByComparator orderByComparator)
874                    throws SystemException {
875                    Object[] finderArgs = new Object[] {
876                                    groupId, statusId,
877                                    
878                                    String.valueOf(start), String.valueOf(end),
879                                    String.valueOf(orderByComparator)
880                            };
881    
882                    List<MembershipRequest> list = (List<MembershipRequest>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_S,
883                                    finderArgs, this);
884    
885                    if (list == null) {
886                            Session session = null;
887    
888                            try {
889                                    session = openSession();
890    
891                                    StringBundler query = null;
892    
893                                    if (orderByComparator != null) {
894                                            query = new StringBundler(4 +
895                                                            (orderByComparator.getOrderByFields().length * 3));
896                                    }
897                                    else {
898                                            query = new StringBundler(4);
899                                    }
900    
901                                    query.append(_SQL_SELECT_MEMBERSHIPREQUEST_WHERE);
902    
903                                    query.append(_FINDER_COLUMN_G_S_GROUPID_2);
904    
905                                    query.append(_FINDER_COLUMN_G_S_STATUSID_2);
906    
907                                    if (orderByComparator != null) {
908                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
909                                                    orderByComparator);
910                                    }
911    
912                                    else {
913                                            query.append(MembershipRequestModelImpl.ORDER_BY_JPQL);
914                                    }
915    
916                                    String sql = query.toString();
917    
918                                    Query q = session.createQuery(sql);
919    
920                                    QueryPos qPos = QueryPos.getInstance(q);
921    
922                                    qPos.add(groupId);
923    
924                                    qPos.add(statusId);
925    
926                                    list = (List<MembershipRequest>)QueryUtil.list(q, getDialect(),
927                                                    start, end);
928                            }
929                            catch (Exception e) {
930                                    throw processException(e);
931                            }
932                            finally {
933                                    if (list == null) {
934                                            list = new ArrayList<MembershipRequest>();
935                                    }
936    
937                                    cacheResult(list);
938    
939                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_S, finderArgs,
940                                            list);
941    
942                                    closeSession(session);
943                            }
944                    }
945    
946                    return list;
947            }
948    
949            public MembershipRequest findByG_S_First(long groupId, int statusId,
950                    OrderByComparator orderByComparator)
951                    throws NoSuchMembershipRequestException, SystemException {
952                    List<MembershipRequest> list = findByG_S(groupId, statusId, 0, 1,
953                                    orderByComparator);
954    
955                    if (list.isEmpty()) {
956                            StringBundler msg = new StringBundler(6);
957    
958                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
959    
960                            msg.append("groupId=");
961                            msg.append(groupId);
962    
963                            msg.append(", statusId=");
964                            msg.append(statusId);
965    
966                            msg.append(StringPool.CLOSE_CURLY_BRACE);
967    
968                            throw new NoSuchMembershipRequestException(msg.toString());
969                    }
970                    else {
971                            return list.get(0);
972                    }
973            }
974    
975            public MembershipRequest findByG_S_Last(long groupId, int statusId,
976                    OrderByComparator orderByComparator)
977                    throws NoSuchMembershipRequestException, SystemException {
978                    int count = countByG_S(groupId, statusId);
979    
980                    List<MembershipRequest> list = findByG_S(groupId, statusId, count - 1,
981                                    count, orderByComparator);
982    
983                    if (list.isEmpty()) {
984                            StringBundler msg = new StringBundler(6);
985    
986                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
987    
988                            msg.append("groupId=");
989                            msg.append(groupId);
990    
991                            msg.append(", statusId=");
992                            msg.append(statusId);
993    
994                            msg.append(StringPool.CLOSE_CURLY_BRACE);
995    
996                            throw new NoSuchMembershipRequestException(msg.toString());
997                    }
998                    else {
999                            return list.get(0);
1000                    }
1001            }
1002    
1003            public MembershipRequest[] findByG_S_PrevAndNext(long membershipRequestId,
1004                    long groupId, int statusId, OrderByComparator orderByComparator)
1005                    throws NoSuchMembershipRequestException, SystemException {
1006                    MembershipRequest membershipRequest = findByPrimaryKey(membershipRequestId);
1007    
1008                    Session session = null;
1009    
1010                    try {
1011                            session = openSession();
1012    
1013                            MembershipRequest[] array = new MembershipRequestImpl[3];
1014    
1015                            array[0] = getByG_S_PrevAndNext(session, membershipRequest,
1016                                            groupId, statusId, orderByComparator, true);
1017    
1018                            array[1] = membershipRequest;
1019    
1020                            array[2] = getByG_S_PrevAndNext(session, membershipRequest,
1021                                            groupId, statusId, orderByComparator, false);
1022    
1023                            return array;
1024                    }
1025                    catch (Exception e) {
1026                            throw processException(e);
1027                    }
1028                    finally {
1029                            closeSession(session);
1030                    }
1031            }
1032    
1033            protected MembershipRequest getByG_S_PrevAndNext(Session session,
1034                    MembershipRequest membershipRequest, long groupId, int statusId,
1035                    OrderByComparator orderByComparator, boolean previous) {
1036                    StringBundler query = null;
1037    
1038                    if (orderByComparator != null) {
1039                            query = new StringBundler(6 +
1040                                            (orderByComparator.getOrderByFields().length * 6));
1041                    }
1042                    else {
1043                            query = new StringBundler(3);
1044                    }
1045    
1046                    query.append(_SQL_SELECT_MEMBERSHIPREQUEST_WHERE);
1047    
1048                    query.append(_FINDER_COLUMN_G_S_GROUPID_2);
1049    
1050                    query.append(_FINDER_COLUMN_G_S_STATUSID_2);
1051    
1052                    if (orderByComparator != null) {
1053                            String[] orderByFields = orderByComparator.getOrderByFields();
1054    
1055                            if (orderByFields.length > 0) {
1056                                    query.append(WHERE_AND);
1057                            }
1058    
1059                            for (int i = 0; i < orderByFields.length; i++) {
1060                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1061                                    query.append(orderByFields[i]);
1062    
1063                                    if ((i + 1) < orderByFields.length) {
1064                                            if (orderByComparator.isAscending() ^ previous) {
1065                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
1066                                            }
1067                                            else {
1068                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
1069                                            }
1070                                    }
1071                                    else {
1072                                            if (orderByComparator.isAscending() ^ previous) {
1073                                                    query.append(WHERE_GREATER_THAN);
1074                                            }
1075                                            else {
1076                                                    query.append(WHERE_LESSER_THAN);
1077                                            }
1078                                    }
1079                            }
1080    
1081                            query.append(ORDER_BY_CLAUSE);
1082    
1083                            for (int i = 0; i < orderByFields.length; i++) {
1084                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1085                                    query.append(orderByFields[i]);
1086    
1087                                    if ((i + 1) < orderByFields.length) {
1088                                            if (orderByComparator.isAscending() ^ previous) {
1089                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
1090                                            }
1091                                            else {
1092                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
1093                                            }
1094                                    }
1095                                    else {
1096                                            if (orderByComparator.isAscending() ^ previous) {
1097                                                    query.append(ORDER_BY_ASC);
1098                                            }
1099                                            else {
1100                                                    query.append(ORDER_BY_DESC);
1101                                            }
1102                                    }
1103                            }
1104                    }
1105    
1106                    else {
1107                            query.append(MembershipRequestModelImpl.ORDER_BY_JPQL);
1108                    }
1109    
1110                    String sql = query.toString();
1111    
1112                    Query q = session.createQuery(sql);
1113    
1114                    q.setFirstResult(0);
1115                    q.setMaxResults(2);
1116    
1117                    QueryPos qPos = QueryPos.getInstance(q);
1118    
1119                    qPos.add(groupId);
1120    
1121                    qPos.add(statusId);
1122    
1123                    if (orderByComparator != null) {
1124                            Object[] values = orderByComparator.getOrderByValues(membershipRequest);
1125    
1126                            for (Object value : values) {
1127                                    qPos.add(value);
1128                            }
1129                    }
1130    
1131                    List<MembershipRequest> list = q.list();
1132    
1133                    if (list.size() == 2) {
1134                            return list.get(1);
1135                    }
1136                    else {
1137                            return null;
1138                    }
1139            }
1140    
1141            public List<MembershipRequest> findAll() throws SystemException {
1142                    return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1143            }
1144    
1145            public List<MembershipRequest> findAll(int start, int end)
1146                    throws SystemException {
1147                    return findAll(start, end, null);
1148            }
1149    
1150            public List<MembershipRequest> findAll(int start, int end,
1151                    OrderByComparator orderByComparator) throws SystemException {
1152                    Object[] finderArgs = new Object[] {
1153                                    String.valueOf(start), String.valueOf(end),
1154                                    String.valueOf(orderByComparator)
1155                            };
1156    
1157                    List<MembershipRequest> list = (List<MembershipRequest>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
1158                                    finderArgs, this);
1159    
1160                    if (list == null) {
1161                            Session session = null;
1162    
1163                            try {
1164                                    session = openSession();
1165    
1166                                    StringBundler query = null;
1167                                    String sql = null;
1168    
1169                                    if (orderByComparator != null) {
1170                                            query = new StringBundler(2 +
1171                                                            (orderByComparator.getOrderByFields().length * 3));
1172    
1173                                            query.append(_SQL_SELECT_MEMBERSHIPREQUEST);
1174    
1175                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1176                                                    orderByComparator);
1177    
1178                                            sql = query.toString();
1179                                    }
1180                                    else {
1181                                            sql = _SQL_SELECT_MEMBERSHIPREQUEST.concat(MembershipRequestModelImpl.ORDER_BY_JPQL);
1182                                    }
1183    
1184                                    Query q = session.createQuery(sql);
1185    
1186                                    if (orderByComparator == null) {
1187                                            list = (List<MembershipRequest>)QueryUtil.list(q,
1188                                                            getDialect(), start, end, false);
1189    
1190                                            Collections.sort(list);
1191                                    }
1192                                    else {
1193                                            list = (List<MembershipRequest>)QueryUtil.list(q,
1194                                                            getDialect(), start, end);
1195                                    }
1196                            }
1197                            catch (Exception e) {
1198                                    throw processException(e);
1199                            }
1200                            finally {
1201                                    if (list == null) {
1202                                            list = new ArrayList<MembershipRequest>();
1203                                    }
1204    
1205                                    cacheResult(list);
1206    
1207                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
1208    
1209                                    closeSession(session);
1210                            }
1211                    }
1212    
1213                    return list;
1214            }
1215    
1216            public void removeByGroupId(long groupId) throws SystemException {
1217                    for (MembershipRequest membershipRequest : findByGroupId(groupId)) {
1218                            remove(membershipRequest);
1219                    }
1220            }
1221    
1222            public void removeByUserId(long userId) throws SystemException {
1223                    for (MembershipRequest membershipRequest : findByUserId(userId)) {
1224                            remove(membershipRequest);
1225                    }
1226            }
1227    
1228            public void removeByG_S(long groupId, int statusId)
1229                    throws SystemException {
1230                    for (MembershipRequest membershipRequest : findByG_S(groupId, statusId)) {
1231                            remove(membershipRequest);
1232                    }
1233            }
1234    
1235            public void removeAll() throws SystemException {
1236                    for (MembershipRequest membershipRequest : findAll()) {
1237                            remove(membershipRequest);
1238                    }
1239            }
1240    
1241            public int countByGroupId(long groupId) throws SystemException {
1242                    Object[] finderArgs = new Object[] { groupId };
1243    
1244                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_GROUPID,
1245                                    finderArgs, this);
1246    
1247                    if (count == null) {
1248                            Session session = null;
1249    
1250                            try {
1251                                    session = openSession();
1252    
1253                                    StringBundler query = new StringBundler(2);
1254    
1255                                    query.append(_SQL_COUNT_MEMBERSHIPREQUEST_WHERE);
1256    
1257                                    query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1258    
1259                                    String sql = query.toString();
1260    
1261                                    Query q = session.createQuery(sql);
1262    
1263                                    QueryPos qPos = QueryPos.getInstance(q);
1264    
1265                                    qPos.add(groupId);
1266    
1267                                    count = (Long)q.uniqueResult();
1268                            }
1269                            catch (Exception e) {
1270                                    throw processException(e);
1271                            }
1272                            finally {
1273                                    if (count == null) {
1274                                            count = Long.valueOf(0);
1275                                    }
1276    
1277                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_GROUPID,
1278                                            finderArgs, count);
1279    
1280                                    closeSession(session);
1281                            }
1282                    }
1283    
1284                    return count.intValue();
1285            }
1286    
1287            public int countByUserId(long userId) throws SystemException {
1288                    Object[] finderArgs = new Object[] { userId };
1289    
1290                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_USERID,
1291                                    finderArgs, this);
1292    
1293                    if (count == null) {
1294                            Session session = null;
1295    
1296                            try {
1297                                    session = openSession();
1298    
1299                                    StringBundler query = new StringBundler(2);
1300    
1301                                    query.append(_SQL_COUNT_MEMBERSHIPREQUEST_WHERE);
1302    
1303                                    query.append(_FINDER_COLUMN_USERID_USERID_2);
1304    
1305                                    String sql = query.toString();
1306    
1307                                    Query q = session.createQuery(sql);
1308    
1309                                    QueryPos qPos = QueryPos.getInstance(q);
1310    
1311                                    qPos.add(userId);
1312    
1313                                    count = (Long)q.uniqueResult();
1314                            }
1315                            catch (Exception e) {
1316                                    throw processException(e);
1317                            }
1318                            finally {
1319                                    if (count == null) {
1320                                            count = Long.valueOf(0);
1321                                    }
1322    
1323                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_USERID,
1324                                            finderArgs, count);
1325    
1326                                    closeSession(session);
1327                            }
1328                    }
1329    
1330                    return count.intValue();
1331            }
1332    
1333            public int countByG_S(long groupId, int statusId) throws SystemException {
1334                    Object[] finderArgs = new Object[] { groupId, statusId };
1335    
1336                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_S,
1337                                    finderArgs, this);
1338    
1339                    if (count == null) {
1340                            Session session = null;
1341    
1342                            try {
1343                                    session = openSession();
1344    
1345                                    StringBundler query = new StringBundler(3);
1346    
1347                                    query.append(_SQL_COUNT_MEMBERSHIPREQUEST_WHERE);
1348    
1349                                    query.append(_FINDER_COLUMN_G_S_GROUPID_2);
1350    
1351                                    query.append(_FINDER_COLUMN_G_S_STATUSID_2);
1352    
1353                                    String sql = query.toString();
1354    
1355                                    Query q = session.createQuery(sql);
1356    
1357                                    QueryPos qPos = QueryPos.getInstance(q);
1358    
1359                                    qPos.add(groupId);
1360    
1361                                    qPos.add(statusId);
1362    
1363                                    count = (Long)q.uniqueResult();
1364                            }
1365                            catch (Exception e) {
1366                                    throw processException(e);
1367                            }
1368                            finally {
1369                                    if (count == null) {
1370                                            count = Long.valueOf(0);
1371                                    }
1372    
1373                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_S, finderArgs,
1374                                            count);
1375    
1376                                    closeSession(session);
1377                            }
1378                    }
1379    
1380                    return count.intValue();
1381            }
1382    
1383            public int countAll() throws SystemException {
1384                    Object[] finderArgs = new Object[0];
1385    
1386                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
1387                                    finderArgs, this);
1388    
1389                    if (count == null) {
1390                            Session session = null;
1391    
1392                            try {
1393                                    session = openSession();
1394    
1395                                    Query q = session.createQuery(_SQL_COUNT_MEMBERSHIPREQUEST);
1396    
1397                                    count = (Long)q.uniqueResult();
1398                            }
1399                            catch (Exception e) {
1400                                    throw processException(e);
1401                            }
1402                            finally {
1403                                    if (count == null) {
1404                                            count = Long.valueOf(0);
1405                                    }
1406    
1407                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
1408                                            count);
1409    
1410                                    closeSession(session);
1411                            }
1412                    }
1413    
1414                    return count.intValue();
1415            }
1416    
1417            public void afterPropertiesSet() {
1418                    String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
1419                                            com.liferay.portal.util.PropsUtil.get(
1420                                                    "value.object.listener.com.liferay.portal.model.MembershipRequest")));
1421    
1422                    if (listenerClassNames.length > 0) {
1423                            try {
1424                                    List<ModelListener<MembershipRequest>> listenersList = new ArrayList<ModelListener<MembershipRequest>>();
1425    
1426                                    for (String listenerClassName : listenerClassNames) {
1427                                            listenersList.add((ModelListener<MembershipRequest>)InstanceFactory.newInstance(
1428                                                            listenerClassName));
1429                                    }
1430    
1431                                    listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
1432                            }
1433                            catch (Exception e) {
1434                                    _log.error(e);
1435                            }
1436                    }
1437            }
1438    
1439            @BeanReference(type = AccountPersistence.class)
1440            protected AccountPersistence accountPersistence;
1441            @BeanReference(type = AddressPersistence.class)
1442            protected AddressPersistence addressPersistence;
1443            @BeanReference(type = BrowserTrackerPersistence.class)
1444            protected BrowserTrackerPersistence browserTrackerPersistence;
1445            @BeanReference(type = ClassNamePersistence.class)
1446            protected ClassNamePersistence classNamePersistence;
1447            @BeanReference(type = CompanyPersistence.class)
1448            protected CompanyPersistence companyPersistence;
1449            @BeanReference(type = ContactPersistence.class)
1450            protected ContactPersistence contactPersistence;
1451            @BeanReference(type = CountryPersistence.class)
1452            protected CountryPersistence countryPersistence;
1453            @BeanReference(type = EmailAddressPersistence.class)
1454            protected EmailAddressPersistence emailAddressPersistence;
1455            @BeanReference(type = GroupPersistence.class)
1456            protected GroupPersistence groupPersistence;
1457            @BeanReference(type = ImagePersistence.class)
1458            protected ImagePersistence imagePersistence;
1459            @BeanReference(type = LayoutPersistence.class)
1460            protected LayoutPersistence layoutPersistence;
1461            @BeanReference(type = LayoutPrototypePersistence.class)
1462            protected LayoutPrototypePersistence layoutPrototypePersistence;
1463            @BeanReference(type = LayoutSetPersistence.class)
1464            protected LayoutSetPersistence layoutSetPersistence;
1465            @BeanReference(type = LayoutSetPrototypePersistence.class)
1466            protected LayoutSetPrototypePersistence layoutSetPrototypePersistence;
1467            @BeanReference(type = ListTypePersistence.class)
1468            protected ListTypePersistence listTypePersistence;
1469            @BeanReference(type = LockPersistence.class)
1470            protected LockPersistence lockPersistence;
1471            @BeanReference(type = MembershipRequestPersistence.class)
1472            protected MembershipRequestPersistence membershipRequestPersistence;
1473            @BeanReference(type = OrganizationPersistence.class)
1474            protected OrganizationPersistence organizationPersistence;
1475            @BeanReference(type = OrgGroupPermissionPersistence.class)
1476            protected OrgGroupPermissionPersistence orgGroupPermissionPersistence;
1477            @BeanReference(type = OrgGroupRolePersistence.class)
1478            protected OrgGroupRolePersistence orgGroupRolePersistence;
1479            @BeanReference(type = OrgLaborPersistence.class)
1480            protected OrgLaborPersistence orgLaborPersistence;
1481            @BeanReference(type = PasswordPolicyPersistence.class)
1482            protected PasswordPolicyPersistence passwordPolicyPersistence;
1483            @BeanReference(type = PasswordPolicyRelPersistence.class)
1484            protected PasswordPolicyRelPersistence passwordPolicyRelPersistence;
1485            @BeanReference(type = PasswordTrackerPersistence.class)
1486            protected PasswordTrackerPersistence passwordTrackerPersistence;
1487            @BeanReference(type = PermissionPersistence.class)
1488            protected PermissionPersistence permissionPersistence;
1489            @BeanReference(type = PhonePersistence.class)
1490            protected PhonePersistence phonePersistence;
1491            @BeanReference(type = PluginSettingPersistence.class)
1492            protected PluginSettingPersistence pluginSettingPersistence;
1493            @BeanReference(type = PortletPersistence.class)
1494            protected PortletPersistence portletPersistence;
1495            @BeanReference(type = PortletItemPersistence.class)
1496            protected PortletItemPersistence portletItemPersistence;
1497            @BeanReference(type = PortletPreferencesPersistence.class)
1498            protected PortletPreferencesPersistence portletPreferencesPersistence;
1499            @BeanReference(type = RegionPersistence.class)
1500            protected RegionPersistence regionPersistence;
1501            @BeanReference(type = ReleasePersistence.class)
1502            protected ReleasePersistence releasePersistence;
1503            @BeanReference(type = ResourcePersistence.class)
1504            protected ResourcePersistence resourcePersistence;
1505            @BeanReference(type = ResourceActionPersistence.class)
1506            protected ResourceActionPersistence resourceActionPersistence;
1507            @BeanReference(type = ResourceCodePersistence.class)
1508            protected ResourceCodePersistence resourceCodePersistence;
1509            @BeanReference(type = ResourcePermissionPersistence.class)
1510            protected ResourcePermissionPersistence resourcePermissionPersistence;
1511            @BeanReference(type = RolePersistence.class)
1512            protected RolePersistence rolePersistence;
1513            @BeanReference(type = ServiceComponentPersistence.class)
1514            protected ServiceComponentPersistence serviceComponentPersistence;
1515            @BeanReference(type = ShardPersistence.class)
1516            protected ShardPersistence shardPersistence;
1517            @BeanReference(type = SubscriptionPersistence.class)
1518            protected SubscriptionPersistence subscriptionPersistence;
1519            @BeanReference(type = TicketPersistence.class)
1520            protected TicketPersistence ticketPersistence;
1521            @BeanReference(type = TeamPersistence.class)
1522            protected TeamPersistence teamPersistence;
1523            @BeanReference(type = UserPersistence.class)
1524            protected UserPersistence userPersistence;
1525            @BeanReference(type = UserGroupPersistence.class)
1526            protected UserGroupPersistence userGroupPersistence;
1527            @BeanReference(type = UserGroupGroupRolePersistence.class)
1528            protected UserGroupGroupRolePersistence userGroupGroupRolePersistence;
1529            @BeanReference(type = UserGroupRolePersistence.class)
1530            protected UserGroupRolePersistence userGroupRolePersistence;
1531            @BeanReference(type = UserIdMapperPersistence.class)
1532            protected UserIdMapperPersistence userIdMapperPersistence;
1533            @BeanReference(type = UserTrackerPersistence.class)
1534            protected UserTrackerPersistence userTrackerPersistence;
1535            @BeanReference(type = UserTrackerPathPersistence.class)
1536            protected UserTrackerPathPersistence userTrackerPathPersistence;
1537            @BeanReference(type = WebDAVPropsPersistence.class)
1538            protected WebDAVPropsPersistence webDAVPropsPersistence;
1539            @BeanReference(type = WebsitePersistence.class)
1540            protected WebsitePersistence websitePersistence;
1541            @BeanReference(type = WorkflowDefinitionLinkPersistence.class)
1542            protected WorkflowDefinitionLinkPersistence workflowDefinitionLinkPersistence;
1543            @BeanReference(type = WorkflowInstanceLinkPersistence.class)
1544            protected WorkflowInstanceLinkPersistence workflowInstanceLinkPersistence;
1545            private static final String _SQL_SELECT_MEMBERSHIPREQUEST = "SELECT membershipRequest FROM MembershipRequest membershipRequest";
1546            private static final String _SQL_SELECT_MEMBERSHIPREQUEST_WHERE = "SELECT membershipRequest FROM MembershipRequest membershipRequest WHERE ";
1547            private static final String _SQL_COUNT_MEMBERSHIPREQUEST = "SELECT COUNT(membershipRequest) FROM MembershipRequest membershipRequest";
1548            private static final String _SQL_COUNT_MEMBERSHIPREQUEST_WHERE = "SELECT COUNT(membershipRequest) FROM MembershipRequest membershipRequest WHERE ";
1549            private static final String _FINDER_COLUMN_GROUPID_GROUPID_2 = "membershipRequest.groupId = ?";
1550            private static final String _FINDER_COLUMN_USERID_USERID_2 = "membershipRequest.userId = ?";
1551            private static final String _FINDER_COLUMN_G_S_GROUPID_2 = "membershipRequest.groupId = ? AND ";
1552            private static final String _FINDER_COLUMN_G_S_STATUSID_2 = "membershipRequest.statusId = ?";
1553            private static final String _ORDER_BY_ENTITY_ALIAS = "membershipRequest.";
1554            private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No MembershipRequest exists with the primary key ";
1555            private static final String _NO_SUCH_ENTITY_WITH_KEY = "No MembershipRequest exists with the key {";
1556            private static Log _log = LogFactoryUtil.getLog(MembershipRequestPersistenceImpl.class);
1557    }