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