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.portlet.tasks.service.persistence;
16  
17  import com.liferay.portal.NoSuchModelException;
18  import com.liferay.portal.SystemException;
19  import com.liferay.portal.kernel.annotation.BeanReference;
20  import com.liferay.portal.kernel.cache.CacheRegistry;
21  import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
22  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
23  import com.liferay.portal.kernel.dao.orm.FinderPath;
24  import com.liferay.portal.kernel.dao.orm.Query;
25  import com.liferay.portal.kernel.dao.orm.QueryPos;
26  import com.liferay.portal.kernel.dao.orm.QueryUtil;
27  import com.liferay.portal.kernel.dao.orm.Session;
28  import com.liferay.portal.kernel.log.Log;
29  import com.liferay.portal.kernel.log.LogFactoryUtil;
30  import com.liferay.portal.kernel.util.GetterUtil;
31  import com.liferay.portal.kernel.util.InstanceFactory;
32  import com.liferay.portal.kernel.util.OrderByComparator;
33  import com.liferay.portal.kernel.util.StringBundler;
34  import com.liferay.portal.kernel.util.StringPool;
35  import com.liferay.portal.kernel.util.StringUtil;
36  import com.liferay.portal.kernel.util.Validator;
37  import com.liferay.portal.model.ModelListener;
38  import com.liferay.portal.service.persistence.BatchSessionUtil;
39  import com.liferay.portal.service.persistence.ResourcePersistence;
40  import com.liferay.portal.service.persistence.UserPersistence;
41  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
42  
43  import com.liferay.portlet.messageboards.service.persistence.MBMessagePersistence;
44  import com.liferay.portlet.social.service.persistence.SocialActivityPersistence;
45  import com.liferay.portlet.tasks.NoSuchProposalException;
46  import com.liferay.portlet.tasks.model.TasksProposal;
47  import com.liferay.portlet.tasks.model.impl.TasksProposalImpl;
48  import com.liferay.portlet.tasks.model.impl.TasksProposalModelImpl;
49  
50  import java.io.Serializable;
51  
52  import java.util.ArrayList;
53  import java.util.Collections;
54  import java.util.List;
55  
56  /**
57   * <a href="TasksProposalPersistenceImpl.java.html"><b><i>View Source</i></b></a>
58   *
59   * <p>
60   * ServiceBuilder generated this class. Modifications in this class will be
61   * overwritten the next time is generated.
62   * </p>
63   *
64   * @author    Brian Wing Shun Chan
65   * @see       TasksProposalPersistence
66   * @see       TasksProposalUtil
67   * @generated
68   */
69  public class TasksProposalPersistenceImpl extends BasePersistenceImpl<TasksProposal>
70      implements TasksProposalPersistence {
71      public static final String FINDER_CLASS_NAME_ENTITY = TasksProposalImpl.class.getName();
72      public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
73          ".List";
74      public static final FinderPath FINDER_PATH_FIND_BY_GROUPID = new FinderPath(TasksProposalModelImpl.ENTITY_CACHE_ENABLED,
75              TasksProposalModelImpl.FINDER_CACHE_ENABLED,
76              FINDER_CLASS_NAME_LIST, "findByGroupId",
77              new String[] {
78                  Long.class.getName(),
79                  
80              "java.lang.Integer", "java.lang.Integer",
81                  "com.liferay.portal.kernel.util.OrderByComparator"
82              });
83      public static final FinderPath FINDER_PATH_COUNT_BY_GROUPID = new FinderPath(TasksProposalModelImpl.ENTITY_CACHE_ENABLED,
84              TasksProposalModelImpl.FINDER_CACHE_ENABLED,
85              FINDER_CLASS_NAME_LIST, "countByGroupId",
86              new String[] { Long.class.getName() });
87      public static final FinderPath FINDER_PATH_FIND_BY_G_U = new FinderPath(TasksProposalModelImpl.ENTITY_CACHE_ENABLED,
88              TasksProposalModelImpl.FINDER_CACHE_ENABLED,
89              FINDER_CLASS_NAME_LIST, "findByG_U",
90              new String[] {
91                  Long.class.getName(), Long.class.getName(),
92                  
93              "java.lang.Integer", "java.lang.Integer",
94                  "com.liferay.portal.kernel.util.OrderByComparator"
95              });
96      public static final FinderPath FINDER_PATH_COUNT_BY_G_U = new FinderPath(TasksProposalModelImpl.ENTITY_CACHE_ENABLED,
97              TasksProposalModelImpl.FINDER_CACHE_ENABLED,
98              FINDER_CLASS_NAME_LIST, "countByG_U",
99              new String[] { Long.class.getName(), Long.class.getName() });
100     public static final FinderPath FINDER_PATH_FETCH_BY_C_C = new FinderPath(TasksProposalModelImpl.ENTITY_CACHE_ENABLED,
101             TasksProposalModelImpl.FINDER_CACHE_ENABLED,
102             FINDER_CLASS_NAME_ENTITY, "fetchByC_C",
103             new String[] { Long.class.getName(), String.class.getName() });
104     public static final FinderPath FINDER_PATH_COUNT_BY_C_C = new FinderPath(TasksProposalModelImpl.ENTITY_CACHE_ENABLED,
105             TasksProposalModelImpl.FINDER_CACHE_ENABLED,
106             FINDER_CLASS_NAME_LIST, "countByC_C",
107             new String[] { Long.class.getName(), String.class.getName() });
108     public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(TasksProposalModelImpl.ENTITY_CACHE_ENABLED,
109             TasksProposalModelImpl.FINDER_CACHE_ENABLED,
110             FINDER_CLASS_NAME_LIST, "findAll", new String[0]);
111     public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(TasksProposalModelImpl.ENTITY_CACHE_ENABLED,
112             TasksProposalModelImpl.FINDER_CACHE_ENABLED,
113             FINDER_CLASS_NAME_LIST, "countAll", new String[0]);
114 
115     public void cacheResult(TasksProposal tasksProposal) {
116         EntityCacheUtil.putResult(TasksProposalModelImpl.ENTITY_CACHE_ENABLED,
117             TasksProposalImpl.class, tasksProposal.getPrimaryKey(),
118             tasksProposal);
119 
120         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_C,
121             new Object[] {
122                 new Long(tasksProposal.getClassNameId()),
123                 
124             tasksProposal.getClassPK()
125             }, tasksProposal);
126     }
127 
128     public void cacheResult(List<TasksProposal> tasksProposals) {
129         for (TasksProposal tasksProposal : tasksProposals) {
130             if (EntityCacheUtil.getResult(
131                         TasksProposalModelImpl.ENTITY_CACHE_ENABLED,
132                         TasksProposalImpl.class, tasksProposal.getPrimaryKey(),
133                         this) == null) {
134                 cacheResult(tasksProposal);
135             }
136         }
137     }
138 
139     public void clearCache() {
140         CacheRegistry.clear(TasksProposalImpl.class.getName());
141         EntityCacheUtil.clearCache(TasksProposalImpl.class.getName());
142         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
143         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
144     }
145 
146     public void clearCache(TasksProposal tasksProposal) {
147         EntityCacheUtil.removeResult(TasksProposalModelImpl.ENTITY_CACHE_ENABLED,
148             TasksProposalImpl.class, tasksProposal.getPrimaryKey());
149 
150         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_C,
151             new Object[] {
152                 new Long(tasksProposal.getClassNameId()),
153                 
154             tasksProposal.getClassPK()
155             });
156     }
157 
158     public TasksProposal create(long proposalId) {
159         TasksProposal tasksProposal = new TasksProposalImpl();
160 
161         tasksProposal.setNew(true);
162         tasksProposal.setPrimaryKey(proposalId);
163 
164         return tasksProposal;
165     }
166 
167     public TasksProposal remove(Serializable primaryKey)
168         throws NoSuchModelException, SystemException {
169         return remove(((Long)primaryKey).longValue());
170     }
171 
172     public TasksProposal remove(long proposalId)
173         throws NoSuchProposalException, SystemException {
174         Session session = null;
175 
176         try {
177             session = openSession();
178 
179             TasksProposal tasksProposal = (TasksProposal)session.get(TasksProposalImpl.class,
180                     new Long(proposalId));
181 
182             if (tasksProposal == null) {
183                 if (_log.isWarnEnabled()) {
184                     _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + proposalId);
185                 }
186 
187                 throw new NoSuchProposalException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
188                     proposalId);
189             }
190 
191             return remove(tasksProposal);
192         }
193         catch (NoSuchProposalException nsee) {
194             throw nsee;
195         }
196         catch (Exception e) {
197             throw processException(e);
198         }
199         finally {
200             closeSession(session);
201         }
202     }
203 
204     protected TasksProposal removeImpl(TasksProposal tasksProposal)
205         throws SystemException {
206         tasksProposal = toUnwrappedModel(tasksProposal);
207 
208         Session session = null;
209 
210         try {
211             session = openSession();
212 
213             BatchSessionUtil.delete(session, tasksProposal);
214         }
215         catch (Exception e) {
216             throw processException(e);
217         }
218         finally {
219             closeSession(session);
220         }
221 
222         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
223 
224         TasksProposalModelImpl tasksProposalModelImpl = (TasksProposalModelImpl)tasksProposal;
225 
226         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_C,
227             new Object[] {
228                 new Long(tasksProposalModelImpl.getOriginalClassNameId()),
229                 
230             tasksProposalModelImpl.getOriginalClassPK()
231             });
232 
233         EntityCacheUtil.removeResult(TasksProposalModelImpl.ENTITY_CACHE_ENABLED,
234             TasksProposalImpl.class, tasksProposal.getPrimaryKey());
235 
236         return tasksProposal;
237     }
238 
239     /**
240      * @deprecated Use {@link BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)}.
241      */
242     public TasksProposal update(TasksProposal tasksProposal)
243         throws SystemException {
244         if (_log.isWarnEnabled()) {
245             _log.warn(
246                 "Using the deprecated update(TasksProposal tasksProposal) method. Use update(TasksProposal tasksProposal, boolean merge) instead.");
247         }
248 
249         return update(tasksProposal, false);
250     }
251 
252     public TasksProposal updateImpl(
253         com.liferay.portlet.tasks.model.TasksProposal tasksProposal,
254         boolean merge) throws SystemException {
255         tasksProposal = toUnwrappedModel(tasksProposal);
256 
257         boolean isNew = tasksProposal.isNew();
258 
259         TasksProposalModelImpl tasksProposalModelImpl = (TasksProposalModelImpl)tasksProposal;
260 
261         Session session = null;
262 
263         try {
264             session = openSession();
265 
266             BatchSessionUtil.update(session, tasksProposal, merge);
267 
268             tasksProposal.setNew(false);
269         }
270         catch (Exception e) {
271             throw processException(e);
272         }
273         finally {
274             closeSession(session);
275         }
276 
277         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
278 
279         EntityCacheUtil.putResult(TasksProposalModelImpl.ENTITY_CACHE_ENABLED,
280             TasksProposalImpl.class, tasksProposal.getPrimaryKey(),
281             tasksProposal);
282 
283         if (!isNew &&
284                 ((tasksProposal.getClassNameId() != tasksProposalModelImpl.getOriginalClassNameId()) ||
285                 !Validator.equals(tasksProposal.getClassPK(),
286                     tasksProposalModelImpl.getOriginalClassPK()))) {
287             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_C,
288                 new Object[] {
289                     new Long(tasksProposalModelImpl.getOriginalClassNameId()),
290                     
291                 tasksProposalModelImpl.getOriginalClassPK()
292                 });
293         }
294 
295         if (isNew ||
296                 ((tasksProposal.getClassNameId() != tasksProposalModelImpl.getOriginalClassNameId()) ||
297                 !Validator.equals(tasksProposal.getClassPK(),
298                     tasksProposalModelImpl.getOriginalClassPK()))) {
299             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_C,
300                 new Object[] {
301                     new Long(tasksProposal.getClassNameId()),
302                     
303                 tasksProposal.getClassPK()
304                 }, tasksProposal);
305         }
306 
307         return tasksProposal;
308     }
309 
310     protected TasksProposal toUnwrappedModel(TasksProposal tasksProposal) {
311         if (tasksProposal instanceof TasksProposalImpl) {
312             return tasksProposal;
313         }
314 
315         TasksProposalImpl tasksProposalImpl = new TasksProposalImpl();
316 
317         tasksProposalImpl.setNew(tasksProposal.isNew());
318         tasksProposalImpl.setPrimaryKey(tasksProposal.getPrimaryKey());
319 
320         tasksProposalImpl.setProposalId(tasksProposal.getProposalId());
321         tasksProposalImpl.setGroupId(tasksProposal.getGroupId());
322         tasksProposalImpl.setCompanyId(tasksProposal.getCompanyId());
323         tasksProposalImpl.setUserId(tasksProposal.getUserId());
324         tasksProposalImpl.setUserName(tasksProposal.getUserName());
325         tasksProposalImpl.setCreateDate(tasksProposal.getCreateDate());
326         tasksProposalImpl.setModifiedDate(tasksProposal.getModifiedDate());
327         tasksProposalImpl.setClassNameId(tasksProposal.getClassNameId());
328         tasksProposalImpl.setClassPK(tasksProposal.getClassPK());
329         tasksProposalImpl.setName(tasksProposal.getName());
330         tasksProposalImpl.setDescription(tasksProposal.getDescription());
331         tasksProposalImpl.setPublishDate(tasksProposal.getPublishDate());
332         tasksProposalImpl.setDueDate(tasksProposal.getDueDate());
333 
334         return tasksProposalImpl;
335     }
336 
337     public TasksProposal findByPrimaryKey(Serializable primaryKey)
338         throws NoSuchModelException, SystemException {
339         return findByPrimaryKey(((Long)primaryKey).longValue());
340     }
341 
342     public TasksProposal findByPrimaryKey(long proposalId)
343         throws NoSuchProposalException, SystemException {
344         TasksProposal tasksProposal = fetchByPrimaryKey(proposalId);
345 
346         if (tasksProposal == null) {
347             if (_log.isWarnEnabled()) {
348                 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + proposalId);
349             }
350 
351             throw new NoSuchProposalException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
352                 proposalId);
353         }
354 
355         return tasksProposal;
356     }
357 
358     public TasksProposal fetchByPrimaryKey(Serializable primaryKey)
359         throws SystemException {
360         return fetchByPrimaryKey(((Long)primaryKey).longValue());
361     }
362 
363     public TasksProposal fetchByPrimaryKey(long proposalId)
364         throws SystemException {
365         TasksProposal tasksProposal = (TasksProposal)EntityCacheUtil.getResult(TasksProposalModelImpl.ENTITY_CACHE_ENABLED,
366                 TasksProposalImpl.class, proposalId, this);
367 
368         if (tasksProposal == null) {
369             Session session = null;
370 
371             try {
372                 session = openSession();
373 
374                 tasksProposal = (TasksProposal)session.get(TasksProposalImpl.class,
375                         new Long(proposalId));
376             }
377             catch (Exception e) {
378                 throw processException(e);
379             }
380             finally {
381                 if (tasksProposal != null) {
382                     cacheResult(tasksProposal);
383                 }
384 
385                 closeSession(session);
386             }
387         }
388 
389         return tasksProposal;
390     }
391 
392     public List<TasksProposal> findByGroupId(long groupId)
393         throws SystemException {
394         return findByGroupId(groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
395     }
396 
397     public List<TasksProposal> findByGroupId(long groupId, int start, int end)
398         throws SystemException {
399         return findByGroupId(groupId, start, end, null);
400     }
401 
402     public List<TasksProposal> findByGroupId(long groupId, int start, int end,
403         OrderByComparator orderByComparator) throws SystemException {
404         Object[] finderArgs = new Object[] {
405                 groupId,
406                 
407                 String.valueOf(start), String.valueOf(end),
408                 String.valueOf(orderByComparator)
409             };
410 
411         List<TasksProposal> list = (List<TasksProposal>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_GROUPID,
412                 finderArgs, this);
413 
414         if (list == null) {
415             StringBundler query = null;
416 
417             if (orderByComparator != null) {
418                 query = new StringBundler(3 +
419                         (orderByComparator.getOrderByFields().length * 3));
420             }
421             else {
422                 query = new StringBundler(3);
423             }
424 
425             query.append(_SQL_SELECT_TASKSPROPOSAL_WHERE);
426 
427             query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
428 
429             if (orderByComparator != null) {
430                 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
431                     orderByComparator);
432             }
433 
434             else {
435                 query.append(TasksProposalModelImpl.ORDER_BY_JPQL);
436             }
437 
438             String sql = query.toString();
439 
440             Session session = null;
441 
442             try {
443                 session = openSession();
444 
445                 Query q = session.createQuery(sql);
446 
447                 QueryPos qPos = QueryPos.getInstance(q);
448 
449                 qPos.add(groupId);
450 
451                 list = (List<TasksProposal>)QueryUtil.list(q, getDialect(),
452                         start, end);
453             }
454             catch (Exception e) {
455                 throw processException(e);
456             }
457             finally {
458                 if (list == null) {
459                     list = new ArrayList<TasksProposal>();
460                 }
461 
462                 cacheResult(list);
463 
464                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_GROUPID,
465                     finderArgs, list);
466 
467                 closeSession(session);
468             }
469         }
470 
471         return list;
472     }
473 
474     public TasksProposal findByGroupId_First(long groupId,
475         OrderByComparator orderByComparator)
476         throws NoSuchProposalException, SystemException {
477         List<TasksProposal> list = findByGroupId(groupId, 0, 1,
478                 orderByComparator);
479 
480         if (list.isEmpty()) {
481             StringBundler msg = new StringBundler(4);
482 
483             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
484 
485             msg.append("groupId=");
486             msg.append(groupId);
487 
488             msg.append(StringPool.CLOSE_CURLY_BRACE);
489 
490             throw new NoSuchProposalException(msg.toString());
491         }
492         else {
493             return list.get(0);
494         }
495     }
496 
497     public TasksProposal findByGroupId_Last(long groupId,
498         OrderByComparator orderByComparator)
499         throws NoSuchProposalException, SystemException {
500         int count = countByGroupId(groupId);
501 
502         List<TasksProposal> list = findByGroupId(groupId, count - 1, count,
503                 orderByComparator);
504 
505         if (list.isEmpty()) {
506             StringBundler msg = new StringBundler(4);
507 
508             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
509 
510             msg.append("groupId=");
511             msg.append(groupId);
512 
513             msg.append(StringPool.CLOSE_CURLY_BRACE);
514 
515             throw new NoSuchProposalException(msg.toString());
516         }
517         else {
518             return list.get(0);
519         }
520     }
521 
522     public TasksProposal[] findByGroupId_PrevAndNext(long proposalId,
523         long groupId, OrderByComparator orderByComparator)
524         throws NoSuchProposalException, SystemException {
525         TasksProposal tasksProposal = findByPrimaryKey(proposalId);
526 
527         Session session = null;
528 
529         try {
530             session = openSession();
531 
532             TasksProposal[] array = new TasksProposalImpl[3];
533 
534             array[0] = getByGroupId_PrevAndNext(session, tasksProposal,
535                     groupId, orderByComparator, true);
536 
537             array[1] = tasksProposal;
538 
539             array[2] = getByGroupId_PrevAndNext(session, tasksProposal,
540                     groupId, orderByComparator, false);
541 
542             return array;
543         }
544         catch (Exception e) {
545             throw processException(e);
546         }
547         finally {
548             closeSession(session);
549         }
550     }
551 
552     protected TasksProposal getByGroupId_PrevAndNext(Session session,
553         TasksProposal tasksProposal, long groupId,
554         OrderByComparator orderByComparator, boolean previous) {
555         StringBundler query = null;
556 
557         if (orderByComparator != null) {
558             query = new StringBundler(6 +
559                     (orderByComparator.getOrderByFields().length * 6));
560         }
561         else {
562             query = new StringBundler(3);
563         }
564 
565         query.append(_SQL_SELECT_TASKSPROPOSAL_WHERE);
566 
567         query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
568 
569         if (orderByComparator != null) {
570             String[] orderByFields = orderByComparator.getOrderByFields();
571 
572             if (orderByFields.length > 0) {
573                 query.append(WHERE_AND);
574             }
575 
576             for (int i = 0; i < orderByFields.length; i++) {
577                 query.append(_ORDER_BY_ENTITY_ALIAS);
578                 query.append(orderByFields[i]);
579 
580                 if ((i + 1) < orderByFields.length) {
581                     if (orderByComparator.isAscending() ^ previous) {
582                         query.append(WHERE_GREATER_THAN_HAS_NEXT);
583                     }
584                     else {
585                         query.append(WHERE_LESSER_THAN_HAS_NEXT);
586                     }
587                 }
588                 else {
589                     if (orderByComparator.isAscending() ^ previous) {
590                         query.append(WHERE_GREATER_THAN);
591                     }
592                     else {
593                         query.append(WHERE_LESSER_THAN);
594                     }
595                 }
596             }
597 
598             query.append(ORDER_BY_CLAUSE);
599 
600             for (int i = 0; i < orderByFields.length; i++) {
601                 query.append(_ORDER_BY_ENTITY_ALIAS);
602                 query.append(orderByFields[i]);
603 
604                 if ((i + 1) < orderByFields.length) {
605                     if (orderByComparator.isAscending() ^ previous) {
606                         query.append(ORDER_BY_ASC_HAS_NEXT);
607                     }
608                     else {
609                         query.append(ORDER_BY_DESC_HAS_NEXT);
610                     }
611                 }
612                 else {
613                     if (orderByComparator.isAscending() ^ previous) {
614                         query.append(ORDER_BY_ASC);
615                     }
616                     else {
617                         query.append(ORDER_BY_DESC);
618                     }
619                 }
620             }
621         }
622 
623         else {
624             query.append(TasksProposalModelImpl.ORDER_BY_JPQL);
625         }
626 
627         String sql = query.toString();
628 
629         Query q = session.createQuery(sql);
630 
631         q.setFirstResult(0);
632         q.setMaxResults(2);
633 
634         QueryPos qPos = QueryPos.getInstance(q);
635 
636         qPos.add(groupId);
637 
638         if (orderByComparator != null) {
639             Object[] values = orderByComparator.getOrderByValues(tasksProposal);
640 
641             for (Object value : values) {
642                 qPos.add(value);
643             }
644         }
645 
646         List<TasksProposal> list = q.list();
647 
648         if (list.size() == 2) {
649             return list.get(1);
650         }
651         else {
652             return null;
653         }
654     }
655 
656     public List<TasksProposal> findByG_U(long groupId, long userId)
657         throws SystemException {
658         return findByG_U(groupId, userId, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
659             null);
660     }
661 
662     public List<TasksProposal> findByG_U(long groupId, long userId, int start,
663         int end) throws SystemException {
664         return findByG_U(groupId, userId, start, end, null);
665     }
666 
667     public List<TasksProposal> findByG_U(long groupId, long userId, int start,
668         int end, OrderByComparator orderByComparator) throws SystemException {
669         Object[] finderArgs = new Object[] {
670                 groupId, userId,
671                 
672                 String.valueOf(start), String.valueOf(end),
673                 String.valueOf(orderByComparator)
674             };
675 
676         List<TasksProposal> list = (List<TasksProposal>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_U,
677                 finderArgs, this);
678 
679         if (list == null) {
680             StringBundler query = null;
681 
682             if (orderByComparator != null) {
683                 query = new StringBundler(4 +
684                         (orderByComparator.getOrderByFields().length * 3));
685             }
686             else {
687                 query = new StringBundler(4);
688             }
689 
690             query.append(_SQL_SELECT_TASKSPROPOSAL_WHERE);
691 
692             query.append(_FINDER_COLUMN_G_U_GROUPID_2);
693 
694             query.append(_FINDER_COLUMN_G_U_USERID_2);
695 
696             if (orderByComparator != null) {
697                 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
698                     orderByComparator);
699             }
700 
701             else {
702                 query.append(TasksProposalModelImpl.ORDER_BY_JPQL);
703             }
704 
705             String sql = query.toString();
706 
707             Session session = null;
708 
709             try {
710                 session = openSession();
711 
712                 Query q = session.createQuery(sql);
713 
714                 QueryPos qPos = QueryPos.getInstance(q);
715 
716                 qPos.add(groupId);
717 
718                 qPos.add(userId);
719 
720                 list = (List<TasksProposal>)QueryUtil.list(q, getDialect(),
721                         start, end);
722             }
723             catch (Exception e) {
724                 throw processException(e);
725             }
726             finally {
727                 if (list == null) {
728                     list = new ArrayList<TasksProposal>();
729                 }
730 
731                 cacheResult(list);
732 
733                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_U, finderArgs,
734                     list);
735 
736                 closeSession(session);
737             }
738         }
739 
740         return list;
741     }
742 
743     public TasksProposal findByG_U_First(long groupId, long userId,
744         OrderByComparator orderByComparator)
745         throws NoSuchProposalException, SystemException {
746         List<TasksProposal> list = findByG_U(groupId, userId, 0, 1,
747                 orderByComparator);
748 
749         if (list.isEmpty()) {
750             StringBundler msg = new StringBundler(6);
751 
752             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
753 
754             msg.append("groupId=");
755             msg.append(groupId);
756 
757             msg.append(", userId=");
758             msg.append(userId);
759 
760             msg.append(StringPool.CLOSE_CURLY_BRACE);
761 
762             throw new NoSuchProposalException(msg.toString());
763         }
764         else {
765             return list.get(0);
766         }
767     }
768 
769     public TasksProposal findByG_U_Last(long groupId, long userId,
770         OrderByComparator orderByComparator)
771         throws NoSuchProposalException, SystemException {
772         int count = countByG_U(groupId, userId);
773 
774         List<TasksProposal> list = findByG_U(groupId, userId, count - 1, count,
775                 orderByComparator);
776 
777         if (list.isEmpty()) {
778             StringBundler msg = new StringBundler(6);
779 
780             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
781 
782             msg.append("groupId=");
783             msg.append(groupId);
784 
785             msg.append(", userId=");
786             msg.append(userId);
787 
788             msg.append(StringPool.CLOSE_CURLY_BRACE);
789 
790             throw new NoSuchProposalException(msg.toString());
791         }
792         else {
793             return list.get(0);
794         }
795     }
796 
797     public TasksProposal[] findByG_U_PrevAndNext(long proposalId, long groupId,
798         long userId, OrderByComparator orderByComparator)
799         throws NoSuchProposalException, SystemException {
800         TasksProposal tasksProposal = findByPrimaryKey(proposalId);
801 
802         Session session = null;
803 
804         try {
805             session = openSession();
806 
807             TasksProposal[] array = new TasksProposalImpl[3];
808 
809             array[0] = getByG_U_PrevAndNext(session, tasksProposal, groupId,
810                     userId, orderByComparator, true);
811 
812             array[1] = tasksProposal;
813 
814             array[2] = getByG_U_PrevAndNext(session, tasksProposal, groupId,
815                     userId, orderByComparator, false);
816 
817             return array;
818         }
819         catch (Exception e) {
820             throw processException(e);
821         }
822         finally {
823             closeSession(session);
824         }
825     }
826 
827     protected TasksProposal getByG_U_PrevAndNext(Session session,
828         TasksProposal tasksProposal, long groupId, long userId,
829         OrderByComparator orderByComparator, boolean previous) {
830         StringBundler query = null;
831 
832         if (orderByComparator != null) {
833             query = new StringBundler(6 +
834                     (orderByComparator.getOrderByFields().length * 6));
835         }
836         else {
837             query = new StringBundler(3);
838         }
839 
840         query.append(_SQL_SELECT_TASKSPROPOSAL_WHERE);
841 
842         query.append(_FINDER_COLUMN_G_U_GROUPID_2);
843 
844         query.append(_FINDER_COLUMN_G_U_USERID_2);
845 
846         if (orderByComparator != null) {
847             String[] orderByFields = orderByComparator.getOrderByFields();
848 
849             if (orderByFields.length > 0) {
850                 query.append(WHERE_AND);
851             }
852 
853             for (int i = 0; i < orderByFields.length; i++) {
854                 query.append(_ORDER_BY_ENTITY_ALIAS);
855                 query.append(orderByFields[i]);
856 
857                 if ((i + 1) < orderByFields.length) {
858                     if (orderByComparator.isAscending() ^ previous) {
859                         query.append(WHERE_GREATER_THAN_HAS_NEXT);
860                     }
861                     else {
862                         query.append(WHERE_LESSER_THAN_HAS_NEXT);
863                     }
864                 }
865                 else {
866                     if (orderByComparator.isAscending() ^ previous) {
867                         query.append(WHERE_GREATER_THAN);
868                     }
869                     else {
870                         query.append(WHERE_LESSER_THAN);
871                     }
872                 }
873             }
874 
875             query.append(ORDER_BY_CLAUSE);
876 
877             for (int i = 0; i < orderByFields.length; i++) {
878                 query.append(_ORDER_BY_ENTITY_ALIAS);
879                 query.append(orderByFields[i]);
880 
881                 if ((i + 1) < orderByFields.length) {
882                     if (orderByComparator.isAscending() ^ previous) {
883                         query.append(ORDER_BY_ASC_HAS_NEXT);
884                     }
885                     else {
886                         query.append(ORDER_BY_DESC_HAS_NEXT);
887                     }
888                 }
889                 else {
890                     if (orderByComparator.isAscending() ^ previous) {
891                         query.append(ORDER_BY_ASC);
892                     }
893                     else {
894                         query.append(ORDER_BY_DESC);
895                     }
896                 }
897             }
898         }
899 
900         else {
901             query.append(TasksProposalModelImpl.ORDER_BY_JPQL);
902         }
903 
904         String sql = query.toString();
905 
906         Query q = session.createQuery(sql);
907 
908         q.setFirstResult(0);
909         q.setMaxResults(2);
910 
911         QueryPos qPos = QueryPos.getInstance(q);
912 
913         qPos.add(groupId);
914 
915         qPos.add(userId);
916 
917         if (orderByComparator != null) {
918             Object[] values = orderByComparator.getOrderByValues(tasksProposal);
919 
920             for (Object value : values) {
921                 qPos.add(value);
922             }
923         }
924 
925         List<TasksProposal> list = q.list();
926 
927         if (list.size() == 2) {
928             return list.get(1);
929         }
930         else {
931             return null;
932         }
933     }
934 
935     public TasksProposal findByC_C(long classNameId, String classPK)
936         throws NoSuchProposalException, SystemException {
937         TasksProposal tasksProposal = fetchByC_C(classNameId, classPK);
938 
939         if (tasksProposal == null) {
940             StringBundler msg = new StringBundler(6);
941 
942             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
943 
944             msg.append("classNameId=");
945             msg.append(classNameId);
946 
947             msg.append(", classPK=");
948             msg.append(classPK);
949 
950             msg.append(StringPool.CLOSE_CURLY_BRACE);
951 
952             if (_log.isWarnEnabled()) {
953                 _log.warn(msg.toString());
954             }
955 
956             throw new NoSuchProposalException(msg.toString());
957         }
958 
959         return tasksProposal;
960     }
961 
962     public TasksProposal fetchByC_C(long classNameId, String classPK)
963         throws SystemException {
964         return fetchByC_C(classNameId, classPK, true);
965     }
966 
967     public TasksProposal fetchByC_C(long classNameId, String classPK,
968         boolean retrieveFromCache) throws SystemException {
969         Object[] finderArgs = new Object[] { classNameId, classPK };
970 
971         Object result = null;
972 
973         if (retrieveFromCache) {
974             result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_C_C,
975                     finderArgs, this);
976         }
977 
978         if (result == null) {
979             StringBundler query = new StringBundler(4);
980 
981             query.append(_SQL_SELECT_TASKSPROPOSAL_WHERE);
982 
983             query.append(_FINDER_COLUMN_C_C_CLASSNAMEID_2);
984 
985             if (classPK == null) {
986                 query.append(_FINDER_COLUMN_C_C_CLASSPK_1);
987             }
988             else {
989                 if (classPK.equals(StringPool.BLANK)) {
990                     query.append(_FINDER_COLUMN_C_C_CLASSPK_3);
991                 }
992                 else {
993                     query.append(_FINDER_COLUMN_C_C_CLASSPK_2);
994                 }
995             }
996 
997             query.append(TasksProposalModelImpl.ORDER_BY_JPQL);
998 
999             String sql = query.toString();
1000
1001            Session session = null;
1002
1003            try {
1004                session = openSession();
1005
1006                Query q = session.createQuery(sql);
1007
1008                QueryPos qPos = QueryPos.getInstance(q);
1009
1010                qPos.add(classNameId);
1011
1012                if (classPK != null) {
1013                    qPos.add(classPK);
1014                }
1015
1016                List<TasksProposal> list = q.list();
1017
1018                result = list;
1019
1020                TasksProposal tasksProposal = null;
1021
1022                if (list.isEmpty()) {
1023                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_C,
1024                        finderArgs, list);
1025                }
1026                else {
1027                    tasksProposal = list.get(0);
1028
1029                    cacheResult(tasksProposal);
1030
1031                    if ((tasksProposal.getClassNameId() != classNameId) ||
1032                            (tasksProposal.getClassPK() == null) ||
1033                            !tasksProposal.getClassPK().equals(classPK)) {
1034                        FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_C,
1035                            finderArgs, tasksProposal);
1036                    }
1037                }
1038
1039                return tasksProposal;
1040            }
1041            catch (Exception e) {
1042                throw processException(e);
1043            }
1044            finally {
1045                if (result == null) {
1046                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_C,
1047                        finderArgs, new ArrayList<TasksProposal>());
1048                }
1049
1050                closeSession(session);
1051            }
1052        }
1053        else {
1054            if (result instanceof List<?>) {
1055                return null;
1056            }
1057            else {
1058                return (TasksProposal)result;
1059            }
1060        }
1061    }
1062
1063    public List<TasksProposal> findAll() throws SystemException {
1064        return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1065    }
1066
1067    public List<TasksProposal> findAll(int start, int end)
1068        throws SystemException {
1069        return findAll(start, end, null);
1070    }
1071
1072    public List<TasksProposal> findAll(int start, int end,
1073        OrderByComparator orderByComparator) throws SystemException {
1074        Object[] finderArgs = new Object[] {
1075                String.valueOf(start), String.valueOf(end),
1076                String.valueOf(orderByComparator)
1077            };
1078
1079        List<TasksProposal> list = (List<TasksProposal>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
1080                finderArgs, this);
1081
1082        if (list == null) {
1083            StringBundler query = null;
1084            String sql = null;
1085
1086            if (orderByComparator != null) {
1087                query = new StringBundler(2 +
1088                        (orderByComparator.getOrderByFields().length * 3));
1089
1090                query.append(_SQL_SELECT_TASKSPROPOSAL);
1091
1092                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1093                    orderByComparator);
1094
1095                sql = query.toString();
1096            }
1097            else {
1098                sql = _SQL_SELECT_TASKSPROPOSAL.concat(TasksProposalModelImpl.ORDER_BY_JPQL);
1099            }
1100
1101            Session session = null;
1102
1103            try {
1104                session = openSession();
1105
1106                Query q = session.createQuery(sql);
1107
1108                if (orderByComparator == null) {
1109                    list = (List<TasksProposal>)QueryUtil.list(q, getDialect(),
1110                            start, end, false);
1111
1112                    Collections.sort(list);
1113                }
1114                else {
1115                    list = (List<TasksProposal>)QueryUtil.list(q, getDialect(),
1116                            start, end);
1117                }
1118            }
1119            catch (Exception e) {
1120                throw processException(e);
1121            }
1122            finally {
1123                if (list == null) {
1124                    list = new ArrayList<TasksProposal>();
1125                }
1126
1127                cacheResult(list);
1128
1129                FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
1130
1131                closeSession(session);
1132            }
1133        }
1134
1135        return list;
1136    }
1137
1138    public void removeByGroupId(long groupId) throws SystemException {
1139        for (TasksProposal tasksProposal : findByGroupId(groupId)) {
1140            remove(tasksProposal);
1141        }
1142    }
1143
1144    public void removeByG_U(long groupId, long userId)
1145        throws SystemException {
1146        for (TasksProposal tasksProposal : findByG_U(groupId, userId)) {
1147            remove(tasksProposal);
1148        }
1149    }
1150
1151    public void removeByC_C(long classNameId, String classPK)
1152        throws NoSuchProposalException, SystemException {
1153        TasksProposal tasksProposal = findByC_C(classNameId, classPK);
1154
1155        remove(tasksProposal);
1156    }
1157
1158    public void removeAll() throws SystemException {
1159        for (TasksProposal tasksProposal : findAll()) {
1160            remove(tasksProposal);
1161        }
1162    }
1163
1164    public int countByGroupId(long groupId) throws SystemException {
1165        Object[] finderArgs = new Object[] { groupId };
1166
1167        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_GROUPID,
1168                finderArgs, this);
1169
1170        if (count == null) {
1171            StringBundler query = new StringBundler(2);
1172
1173            query.append(_SQL_COUNT_TASKSPROPOSAL_WHERE);
1174
1175            query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1176
1177            String sql = query.toString();
1178
1179            Session session = null;
1180
1181            try {
1182                session = openSession();
1183
1184                Query q = session.createQuery(sql);
1185
1186                QueryPos qPos = QueryPos.getInstance(q);
1187
1188                qPos.add(groupId);
1189
1190                count = (Long)q.uniqueResult();
1191            }
1192            catch (Exception e) {
1193                throw processException(e);
1194            }
1195            finally {
1196                if (count == null) {
1197                    count = Long.valueOf(0);
1198                }
1199
1200                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_GROUPID,
1201                    finderArgs, count);
1202
1203                closeSession(session);
1204            }
1205        }
1206
1207        return count.intValue();
1208    }
1209
1210    public int countByG_U(long groupId, long userId) throws SystemException {
1211        Object[] finderArgs = new Object[] { groupId, userId };
1212
1213        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_U,
1214                finderArgs, this);
1215
1216        if (count == null) {
1217            StringBundler query = new StringBundler(3);
1218
1219            query.append(_SQL_COUNT_TASKSPROPOSAL_WHERE);
1220
1221            query.append(_FINDER_COLUMN_G_U_GROUPID_2);
1222
1223            query.append(_FINDER_COLUMN_G_U_USERID_2);
1224
1225            String sql = query.toString();
1226
1227            Session session = null;
1228
1229            try {
1230                session = openSession();
1231
1232                Query q = session.createQuery(sql);
1233
1234                QueryPos qPos = QueryPos.getInstance(q);
1235
1236                qPos.add(groupId);
1237
1238                qPos.add(userId);
1239
1240                count = (Long)q.uniqueResult();
1241            }
1242            catch (Exception e) {
1243                throw processException(e);
1244            }
1245            finally {
1246                if (count == null) {
1247                    count = Long.valueOf(0);
1248                }
1249
1250                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_U, finderArgs,
1251                    count);
1252
1253                closeSession(session);
1254            }
1255        }
1256
1257        return count.intValue();
1258    }
1259
1260    public int countByC_C(long classNameId, String classPK)
1261        throws SystemException {
1262        Object[] finderArgs = new Object[] { classNameId, classPK };
1263
1264        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_C,
1265                finderArgs, this);
1266
1267        if (count == null) {
1268            StringBundler query = new StringBundler(3);
1269
1270            query.append(_SQL_COUNT_TASKSPROPOSAL_WHERE);
1271
1272            query.append(_FINDER_COLUMN_C_C_CLASSNAMEID_2);
1273
1274            if (classPK == null) {
1275                query.append(_FINDER_COLUMN_C_C_CLASSPK_1);
1276            }
1277            else {
1278                if (classPK.equals(StringPool.BLANK)) {
1279                    query.append(_FINDER_COLUMN_C_C_CLASSPK_3);
1280                }
1281                else {
1282                    query.append(_FINDER_COLUMN_C_C_CLASSPK_2);
1283                }
1284            }
1285
1286            String sql = query.toString();
1287
1288            Session session = null;
1289
1290            try {
1291                session = openSession();
1292
1293                Query q = session.createQuery(sql);
1294
1295                QueryPos qPos = QueryPos.getInstance(q);
1296
1297                qPos.add(classNameId);
1298
1299                if (classPK != null) {
1300                    qPos.add(classPK);
1301                }
1302
1303                count = (Long)q.uniqueResult();
1304            }
1305            catch (Exception e) {
1306                throw processException(e);
1307            }
1308            finally {
1309                if (count == null) {
1310                    count = Long.valueOf(0);
1311                }
1312
1313                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_C, finderArgs,
1314                    count);
1315
1316                closeSession(session);
1317            }
1318        }
1319
1320        return count.intValue();
1321    }
1322
1323    public int countAll() throws SystemException {
1324        Object[] finderArgs = new Object[0];
1325
1326        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
1327                finderArgs, this);
1328
1329        if (count == null) {
1330            Session session = null;
1331
1332            try {
1333                session = openSession();
1334
1335                Query q = session.createQuery(_SQL_COUNT_TASKSPROPOSAL);
1336
1337                count = (Long)q.uniqueResult();
1338            }
1339            catch (Exception e) {
1340                throw processException(e);
1341            }
1342            finally {
1343                if (count == null) {
1344                    count = Long.valueOf(0);
1345                }
1346
1347                FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
1348                    count);
1349
1350                closeSession(session);
1351            }
1352        }
1353
1354        return count.intValue();
1355    }
1356
1357    public void afterPropertiesSet() {
1358        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
1359                    com.liferay.portal.util.PropsUtil.get(
1360                        "value.object.listener.com.liferay.portlet.tasks.model.TasksProposal")));
1361
1362        if (listenerClassNames.length > 0) {
1363            try {
1364                List<ModelListener<TasksProposal>> listenersList = new ArrayList<ModelListener<TasksProposal>>();
1365
1366                for (String listenerClassName : listenerClassNames) {
1367                    listenersList.add((ModelListener<TasksProposal>)InstanceFactory.newInstance(
1368                            listenerClassName));
1369                }
1370
1371                listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
1372            }
1373            catch (Exception e) {
1374                _log.error(e);
1375            }
1376        }
1377    }
1378
1379    public void destroy() {
1380        EntityCacheUtil.removeCache(TasksProposalImpl.class.getName());
1381        FinderCacheUtil.removeCache(FINDER_CLASS_NAME_ENTITY);
1382        FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST);
1383    }
1384
1385    @BeanReference(type = TasksProposalPersistence.class)
1386    protected TasksProposalPersistence tasksProposalPersistence;
1387    @BeanReference(type = TasksReviewPersistence.class)
1388    protected TasksReviewPersistence tasksReviewPersistence;
1389    @BeanReference(type = ResourcePersistence.class)
1390    protected ResourcePersistence resourcePersistence;
1391    @BeanReference(type = UserPersistence.class)
1392    protected UserPersistence userPersistence;
1393    @BeanReference(type = MBMessagePersistence.class)
1394    protected MBMessagePersistence mbMessagePersistence;
1395    @BeanReference(type = SocialActivityPersistence.class)
1396    protected SocialActivityPersistence socialActivityPersistence;
1397    private static final String _SQL_SELECT_TASKSPROPOSAL = "SELECT tasksProposal FROM TasksProposal tasksProposal";
1398    private static final String _SQL_SELECT_TASKSPROPOSAL_WHERE = "SELECT tasksProposal FROM TasksProposal tasksProposal WHERE ";
1399    private static final String _SQL_COUNT_TASKSPROPOSAL = "SELECT COUNT(tasksProposal) FROM TasksProposal tasksProposal";
1400    private static final String _SQL_COUNT_TASKSPROPOSAL_WHERE = "SELECT COUNT(tasksProposal) FROM TasksProposal tasksProposal WHERE ";
1401    private static final String _FINDER_COLUMN_GROUPID_GROUPID_2 = "tasksProposal.groupId = ?";
1402    private static final String _FINDER_COLUMN_G_U_GROUPID_2 = "tasksProposal.groupId = ? AND ";
1403    private static final String _FINDER_COLUMN_G_U_USERID_2 = "tasksProposal.userId = ?";
1404    private static final String _FINDER_COLUMN_C_C_CLASSNAMEID_2 = "tasksProposal.classNameId = ? AND ";
1405    private static final String _FINDER_COLUMN_C_C_CLASSPK_1 = "tasksProposal.classPK IS NULL";
1406    private static final String _FINDER_COLUMN_C_C_CLASSPK_2 = "tasksProposal.classPK = ?";
1407    private static final String _FINDER_COLUMN_C_C_CLASSPK_3 = "(tasksProposal.classPK IS NULL OR tasksProposal.classPK = ?)";
1408    private static final String _ORDER_BY_ENTITY_ALIAS = "tasksProposal.";
1409    private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No TasksProposal exists with the primary key ";
1410    private static final String _NO_SUCH_ENTITY_WITH_KEY = "No TasksProposal exists with the key {";
1411    private static Log _log = LogFactoryUtil.getLog(TasksProposalPersistenceImpl.class);
1412}