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