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.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.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     /**
261      * @deprecated Use {@link BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)}.
262      */
263     public TasksProposal update(TasksProposal tasksProposal)
264         throws SystemException {
265         if (_log.isWarnEnabled()) {
266             _log.warn(
267                 "Using the deprecated update(TasksProposal tasksProposal) method. Use update(TasksProposal tasksProposal, boolean merge) instead.");
268         }
269 
270         return update(tasksProposal, false);
271     }
272 
273     public TasksProposal updateImpl(
274         com.liferay.portlet.tasks.model.TasksProposal tasksProposal,
275         boolean merge) throws SystemException {
276         tasksProposal = toUnwrappedModel(tasksProposal);
277 
278         boolean isNew = tasksProposal.isNew();
279 
280         TasksProposalModelImpl tasksProposalModelImpl = (TasksProposalModelImpl)tasksProposal;
281 
282         Session session = null;
283 
284         try {
285             session = openSession();
286 
287             BatchSessionUtil.update(session, tasksProposal, merge);
288 
289             tasksProposal.setNew(false);
290         }
291         catch (Exception e) {
292             throw processException(e);
293         }
294         finally {
295             closeSession(session);
296         }
297 
298         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
299 
300         EntityCacheUtil.putResult(TasksProposalModelImpl.ENTITY_CACHE_ENABLED,
301             TasksProposalImpl.class, tasksProposal.getPrimaryKey(),
302             tasksProposal);
303 
304         if (!isNew &&
305                 ((tasksProposal.getClassNameId() != tasksProposalModelImpl.getOriginalClassNameId()) ||
306                 !Validator.equals(tasksProposal.getClassPK(),
307                     tasksProposalModelImpl.getOriginalClassPK()))) {
308             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_C,
309                 new Object[] {
310                     new Long(tasksProposalModelImpl.getOriginalClassNameId()),
311                     
312                 tasksProposalModelImpl.getOriginalClassPK()
313                 });
314         }
315 
316         if (isNew ||
317                 ((tasksProposal.getClassNameId() != tasksProposalModelImpl.getOriginalClassNameId()) ||
318                 !Validator.equals(tasksProposal.getClassPK(),
319                     tasksProposalModelImpl.getOriginalClassPK()))) {
320             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_C,
321                 new Object[] {
322                     new Long(tasksProposal.getClassNameId()),
323                     
324                 tasksProposal.getClassPK()
325                 }, tasksProposal);
326         }
327 
328         return tasksProposal;
329     }
330 
331     protected TasksProposal toUnwrappedModel(TasksProposal tasksProposal) {
332         if (tasksProposal instanceof TasksProposalImpl) {
333             return tasksProposal;
334         }
335 
336         TasksProposalImpl tasksProposalImpl = new TasksProposalImpl();
337 
338         tasksProposalImpl.setNew(tasksProposal.isNew());
339         tasksProposalImpl.setPrimaryKey(tasksProposal.getPrimaryKey());
340 
341         tasksProposalImpl.setProposalId(tasksProposal.getProposalId());
342         tasksProposalImpl.setGroupId(tasksProposal.getGroupId());
343         tasksProposalImpl.setCompanyId(tasksProposal.getCompanyId());
344         tasksProposalImpl.setUserId(tasksProposal.getUserId());
345         tasksProposalImpl.setUserName(tasksProposal.getUserName());
346         tasksProposalImpl.setCreateDate(tasksProposal.getCreateDate());
347         tasksProposalImpl.setModifiedDate(tasksProposal.getModifiedDate());
348         tasksProposalImpl.setClassNameId(tasksProposal.getClassNameId());
349         tasksProposalImpl.setClassPK(tasksProposal.getClassPK());
350         tasksProposalImpl.setName(tasksProposal.getName());
351         tasksProposalImpl.setDescription(tasksProposal.getDescription());
352         tasksProposalImpl.setPublishDate(tasksProposal.getPublishDate());
353         tasksProposalImpl.setDueDate(tasksProposal.getDueDate());
354 
355         return tasksProposalImpl;
356     }
357 
358     public TasksProposal findByPrimaryKey(Serializable primaryKey)
359         throws NoSuchModelException, SystemException {
360         return findByPrimaryKey(((Long)primaryKey).longValue());
361     }
362 
363     public TasksProposal findByPrimaryKey(long proposalId)
364         throws NoSuchProposalException, SystemException {
365         TasksProposal tasksProposal = fetchByPrimaryKey(proposalId);
366 
367         if (tasksProposal == null) {
368             if (_log.isWarnEnabled()) {
369                 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + proposalId);
370             }
371 
372             throw new NoSuchProposalException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
373                 proposalId);
374         }
375 
376         return tasksProposal;
377     }
378 
379     public TasksProposal fetchByPrimaryKey(Serializable primaryKey)
380         throws SystemException {
381         return fetchByPrimaryKey(((Long)primaryKey).longValue());
382     }
383 
384     public TasksProposal fetchByPrimaryKey(long proposalId)
385         throws SystemException {
386         TasksProposal tasksProposal = (TasksProposal)EntityCacheUtil.getResult(TasksProposalModelImpl.ENTITY_CACHE_ENABLED,
387                 TasksProposalImpl.class, proposalId, this);
388 
389         if (tasksProposal == null) {
390             Session session = null;
391 
392             try {
393                 session = openSession();
394 
395                 tasksProposal = (TasksProposal)session.get(TasksProposalImpl.class,
396                         new Long(proposalId));
397             }
398             catch (Exception e) {
399                 throw processException(e);
400             }
401             finally {
402                 if (tasksProposal != null) {
403                     cacheResult(tasksProposal);
404                 }
405 
406                 closeSession(session);
407             }
408         }
409 
410         return tasksProposal;
411     }
412 
413     public List<TasksProposal> findByGroupId(long groupId)
414         throws SystemException {
415         Object[] finderArgs = new Object[] { new Long(groupId) };
416 
417         List<TasksProposal> list = (List<TasksProposal>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_GROUPID,
418                 finderArgs, this);
419 
420         if (list == null) {
421             Session session = null;
422 
423             try {
424                 session = openSession();
425 
426                 StringBundler query = new StringBundler(3);
427 
428                 query.append(_SQL_SELECT_TASKSPROPOSAL_WHERE);
429 
430                 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
431 
432                 query.append(TasksProposalModelImpl.ORDER_BY_JPQL);
433 
434                 String sql = query.toString();
435 
436                 Query q = session.createQuery(sql);
437 
438                 QueryPos qPos = QueryPos.getInstance(q);
439 
440                 qPos.add(groupId);
441 
442                 list = q.list();
443             }
444             catch (Exception e) {
445                 throw processException(e);
446             }
447             finally {
448                 if (list == null) {
449                     list = new ArrayList<TasksProposal>();
450                 }
451 
452                 cacheResult(list);
453 
454                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_GROUPID,
455                     finderArgs, list);
456 
457                 closeSession(session);
458             }
459         }
460 
461         return list;
462     }
463 
464     public List<TasksProposal> findByGroupId(long groupId, int start, int end)
465         throws SystemException {
466         return findByGroupId(groupId, start, end, null);
467     }
468 
469     public List<TasksProposal> findByGroupId(long groupId, int start, int end,
470         OrderByComparator orderByComparator) throws SystemException {
471         Object[] finderArgs = new Object[] {
472                 new Long(groupId),
473                 
474                 String.valueOf(start), String.valueOf(end),
475                 String.valueOf(orderByComparator)
476             };
477 
478         List<TasksProposal> list = (List<TasksProposal>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_GROUPID,
479                 finderArgs, this);
480 
481         if (list == null) {
482             Session session = null;
483 
484             try {
485                 session = openSession();
486 
487                 StringBundler query = null;
488 
489                 if (orderByComparator != null) {
490                     query = new StringBundler(3 +
491                             (orderByComparator.getOrderByFields().length * 3));
492                 }
493                 else {
494                     query = new StringBundler(3);
495                 }
496 
497                 query.append(_SQL_SELECT_TASKSPROPOSAL_WHERE);
498 
499                 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
500 
501                 if (orderByComparator != null) {
502                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
503                         orderByComparator);
504                 }
505 
506                 else {
507                     query.append(TasksProposalModelImpl.ORDER_BY_JPQL);
508                 }
509 
510                 String sql = query.toString();
511 
512                 Query q = session.createQuery(sql);
513 
514                 QueryPos qPos = QueryPos.getInstance(q);
515 
516                 qPos.add(groupId);
517 
518                 list = (List<TasksProposal>)QueryUtil.list(q, getDialect(),
519                         start, end);
520             }
521             catch (Exception e) {
522                 throw processException(e);
523             }
524             finally {
525                 if (list == null) {
526                     list = new ArrayList<TasksProposal>();
527                 }
528 
529                 cacheResult(list);
530 
531                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_GROUPID,
532                     finderArgs, list);
533 
534                 closeSession(session);
535             }
536         }
537 
538         return list;
539     }
540 
541     public TasksProposal findByGroupId_First(long groupId,
542         OrderByComparator orderByComparator)
543         throws NoSuchProposalException, SystemException {
544         List<TasksProposal> list = findByGroupId(groupId, 0, 1,
545                 orderByComparator);
546 
547         if (list.isEmpty()) {
548             StringBundler msg = new StringBundler(4);
549 
550             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
551 
552             msg.append("groupId=");
553             msg.append(groupId);
554 
555             msg.append(StringPool.CLOSE_CURLY_BRACE);
556 
557             throw new NoSuchProposalException(msg.toString());
558         }
559         else {
560             return list.get(0);
561         }
562     }
563 
564     public TasksProposal findByGroupId_Last(long groupId,
565         OrderByComparator orderByComparator)
566         throws NoSuchProposalException, SystemException {
567         int count = countByGroupId(groupId);
568 
569         List<TasksProposal> list = findByGroupId(groupId, count - 1, count,
570                 orderByComparator);
571 
572         if (list.isEmpty()) {
573             StringBundler msg = new StringBundler(4);
574 
575             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
576 
577             msg.append("groupId=");
578             msg.append(groupId);
579 
580             msg.append(StringPool.CLOSE_CURLY_BRACE);
581 
582             throw new NoSuchProposalException(msg.toString());
583         }
584         else {
585             return list.get(0);
586         }
587     }
588 
589     public TasksProposal[] findByGroupId_PrevAndNext(long proposalId,
590         long groupId, OrderByComparator orderByComparator)
591         throws NoSuchProposalException, SystemException {
592         TasksProposal tasksProposal = findByPrimaryKey(proposalId);
593 
594         int count = countByGroupId(groupId);
595 
596         Session session = null;
597 
598         try {
599             session = openSession();
600 
601             StringBundler query = null;
602 
603             if (orderByComparator != null) {
604                 query = new StringBundler(3 +
605                         (orderByComparator.getOrderByFields().length * 3));
606             }
607             else {
608                 query = new StringBundler(3);
609             }
610 
611             query.append(_SQL_SELECT_TASKSPROPOSAL_WHERE);
612 
613             query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
614 
615             if (orderByComparator != null) {
616                 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
617                     orderByComparator);
618             }
619 
620             else {
621                 query.append(TasksProposalModelImpl.ORDER_BY_JPQL);
622             }
623 
624             String sql = query.toString();
625 
626             Query q = session.createQuery(sql);
627 
628             QueryPos qPos = QueryPos.getInstance(q);
629 
630             qPos.add(groupId);
631 
632             Object[] objArray = QueryUtil.getPrevAndNext(q, count,
633                     orderByComparator, tasksProposal);
634 
635             TasksProposal[] array = new TasksProposalImpl[3];
636 
637             array[0] = (TasksProposal)objArray[0];
638             array[1] = (TasksProposal)objArray[1];
639             array[2] = (TasksProposal)objArray[2];
640 
641             return array;
642         }
643         catch (Exception e) {
644             throw processException(e);
645         }
646         finally {
647             closeSession(session);
648         }
649     }
650 
651     public List<TasksProposal> findByG_U(long groupId, long userId)
652         throws SystemException {
653         Object[] finderArgs = new Object[] { new Long(groupId), new Long(userId) };
654 
655         List<TasksProposal> list = (List<TasksProposal>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_U,
656                 finderArgs, this);
657 
658         if (list == null) {
659             Session session = null;
660 
661             try {
662                 session = openSession();
663 
664                 StringBundler query = new StringBundler(4);
665 
666                 query.append(_SQL_SELECT_TASKSPROPOSAL_WHERE);
667 
668                 query.append(_FINDER_COLUMN_G_U_GROUPID_2);
669 
670                 query.append(_FINDER_COLUMN_G_U_USERID_2);
671 
672                 query.append(TasksProposalModelImpl.ORDER_BY_JPQL);
673 
674                 String sql = query.toString();
675 
676                 Query q = session.createQuery(sql);
677 
678                 QueryPos qPos = QueryPos.getInstance(q);
679 
680                 qPos.add(groupId);
681 
682                 qPos.add(userId);
683 
684                 list = q.list();
685             }
686             catch (Exception e) {
687                 throw processException(e);
688             }
689             finally {
690                 if (list == null) {
691                     list = new ArrayList<TasksProposal>();
692                 }
693 
694                 cacheResult(list);
695 
696                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_U, finderArgs,
697                     list);
698 
699                 closeSession(session);
700             }
701         }
702 
703         return list;
704     }
705 
706     public List<TasksProposal> findByG_U(long groupId, long userId, int start,
707         int end) throws SystemException {
708         return findByG_U(groupId, userId, start, end, null);
709     }
710 
711     public List<TasksProposal> findByG_U(long groupId, long userId, int start,
712         int end, OrderByComparator orderByComparator) throws SystemException {
713         Object[] finderArgs = new Object[] {
714                 new Long(groupId), new Long(userId),
715                 
716                 String.valueOf(start), String.valueOf(end),
717                 String.valueOf(orderByComparator)
718             };
719 
720         List<TasksProposal> list = (List<TasksProposal>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_G_U,
721                 finderArgs, this);
722 
723         if (list == null) {
724             Session session = null;
725 
726             try {
727                 session = openSession();
728 
729                 StringBundler query = null;
730 
731                 if (orderByComparator != null) {
732                     query = new StringBundler(4 +
733                             (orderByComparator.getOrderByFields().length * 3));
734                 }
735                 else {
736                     query = new StringBundler(4);
737                 }
738 
739                 query.append(_SQL_SELECT_TASKSPROPOSAL_WHERE);
740 
741                 query.append(_FINDER_COLUMN_G_U_GROUPID_2);
742 
743                 query.append(_FINDER_COLUMN_G_U_USERID_2);
744 
745                 if (orderByComparator != null) {
746                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
747                         orderByComparator);
748                 }
749 
750                 else {
751                     query.append(TasksProposalModelImpl.ORDER_BY_JPQL);
752                 }
753 
754                 String sql = query.toString();
755 
756                 Query q = session.createQuery(sql);
757 
758                 QueryPos qPos = QueryPos.getInstance(q);
759 
760                 qPos.add(groupId);
761 
762                 qPos.add(userId);
763 
764                 list = (List<TasksProposal>)QueryUtil.list(q, getDialect(),
765                         start, end);
766             }
767             catch (Exception e) {
768                 throw processException(e);
769             }
770             finally {
771                 if (list == null) {
772                     list = new ArrayList<TasksProposal>();
773                 }
774 
775                 cacheResult(list);
776 
777                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_G_U,
778                     finderArgs, list);
779 
780                 closeSession(session);
781             }
782         }
783 
784         return list;
785     }
786 
787     public TasksProposal findByG_U_First(long groupId, long userId,
788         OrderByComparator orderByComparator)
789         throws NoSuchProposalException, SystemException {
790         List<TasksProposal> list = findByG_U(groupId, userId, 0, 1,
791                 orderByComparator);
792 
793         if (list.isEmpty()) {
794             StringBundler msg = new StringBundler(6);
795 
796             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
797 
798             msg.append("groupId=");
799             msg.append(groupId);
800 
801             msg.append(", userId=");
802             msg.append(userId);
803 
804             msg.append(StringPool.CLOSE_CURLY_BRACE);
805 
806             throw new NoSuchProposalException(msg.toString());
807         }
808         else {
809             return list.get(0);
810         }
811     }
812 
813     public TasksProposal findByG_U_Last(long groupId, long userId,
814         OrderByComparator orderByComparator)
815         throws NoSuchProposalException, SystemException {
816         int count = countByG_U(groupId, userId);
817 
818         List<TasksProposal> list = findByG_U(groupId, userId, count - 1, count,
819                 orderByComparator);
820 
821         if (list.isEmpty()) {
822             StringBundler msg = new StringBundler(6);
823 
824             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
825 
826             msg.append("groupId=");
827             msg.append(groupId);
828 
829             msg.append(", userId=");
830             msg.append(userId);
831 
832             msg.append(StringPool.CLOSE_CURLY_BRACE);
833 
834             throw new NoSuchProposalException(msg.toString());
835         }
836         else {
837             return list.get(0);
838         }
839     }
840 
841     public TasksProposal[] findByG_U_PrevAndNext(long proposalId, long groupId,
842         long userId, OrderByComparator orderByComparator)
843         throws NoSuchProposalException, SystemException {
844         TasksProposal tasksProposal = findByPrimaryKey(proposalId);
845 
846         int count = countByG_U(groupId, userId);
847 
848         Session session = null;
849 
850         try {
851             session = openSession();
852 
853             StringBundler query = null;
854 
855             if (orderByComparator != null) {
856                 query = new StringBundler(4 +
857                         (orderByComparator.getOrderByFields().length * 3));
858             }
859             else {
860                 query = new StringBundler(4);
861             }
862 
863             query.append(_SQL_SELECT_TASKSPROPOSAL_WHERE);
864 
865             query.append(_FINDER_COLUMN_G_U_GROUPID_2);
866 
867             query.append(_FINDER_COLUMN_G_U_USERID_2);
868 
869             if (orderByComparator != null) {
870                 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
871                     orderByComparator);
872             }
873 
874             else {
875                 query.append(TasksProposalModelImpl.ORDER_BY_JPQL);
876             }
877 
878             String sql = query.toString();
879 
880             Query q = session.createQuery(sql);
881 
882             QueryPos qPos = QueryPos.getInstance(q);
883 
884             qPos.add(groupId);
885 
886             qPos.add(userId);
887 
888             Object[] objArray = QueryUtil.getPrevAndNext(q, count,
889                     orderByComparator, tasksProposal);
890 
891             TasksProposal[] array = new TasksProposalImpl[3];
892 
893             array[0] = (TasksProposal)objArray[0];
894             array[1] = (TasksProposal)objArray[1];
895             array[2] = (TasksProposal)objArray[2];
896 
897             return array;
898         }
899         catch (Exception e) {
900             throw processException(e);
901         }
902         finally {
903             closeSession(session);
904         }
905     }
906 
907     public TasksProposal findByC_C(long classNameId, String classPK)
908         throws NoSuchProposalException, SystemException {
909         TasksProposal tasksProposal = fetchByC_C(classNameId, classPK);
910 
911         if (tasksProposal == null) {
912             StringBundler msg = new StringBundler(6);
913 
914             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
915 
916             msg.append("classNameId=");
917             msg.append(classNameId);
918 
919             msg.append(", classPK=");
920             msg.append(classPK);
921 
922             msg.append(StringPool.CLOSE_CURLY_BRACE);
923 
924             if (_log.isWarnEnabled()) {
925                 _log.warn(msg.toString());
926             }
927 
928             throw new NoSuchProposalException(msg.toString());
929         }
930 
931         return tasksProposal;
932     }
933 
934     public TasksProposal fetchByC_C(long classNameId, String classPK)
935         throws SystemException {
936         return fetchByC_C(classNameId, classPK, true);
937     }
938 
939     public TasksProposal fetchByC_C(long classNameId, String classPK,
940         boolean retrieveFromCache) throws SystemException {
941         Object[] finderArgs = new Object[] { new Long(classNameId), classPK };
942 
943         Object result = null;
944 
945         if (retrieveFromCache) {
946             result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_C_C,
947                     finderArgs, this);
948         }
949 
950         if (result == null) {
951             Session session = null;
952 
953             try {
954                 session = openSession();
955 
956                 StringBundler query = new StringBundler(4);
957 
958                 query.append(_SQL_SELECT_TASKSPROPOSAL_WHERE);
959 
960                 query.append(_FINDER_COLUMN_C_C_CLASSNAMEID_2);
961 
962                 if (classPK == null) {
963                     query.append(_FINDER_COLUMN_C_C_CLASSPK_1);
964                 }
965                 else {
966                     if (classPK.equals(StringPool.BLANK)) {
967                         query.append(_FINDER_COLUMN_C_C_CLASSPK_3);
968                     }
969                     else {
970                         query.append(_FINDER_COLUMN_C_C_CLASSPK_2);
971                     }
972                 }
973 
974                 query.append(TasksProposalModelImpl.ORDER_BY_JPQL);
975 
976                 String sql = query.toString();
977 
978                 Query q = session.createQuery(sql);
979 
980                 QueryPos qPos = QueryPos.getInstance(q);
981 
982                 qPos.add(classNameId);
983 
984                 if (classPK != null) {
985                     qPos.add(classPK);
986                 }
987 
988                 List<TasksProposal> list = q.list();
989 
990                 result = list;
991 
992                 TasksProposal tasksProposal = null;
993 
994                 if (list.isEmpty()) {
995                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_C,
996                         finderArgs, list);
997                 }
998                 else {
999                     tasksProposal = list.get(0);
1000
1001                    cacheResult(tasksProposal);
1002
1003                    if ((tasksProposal.getClassNameId() != classNameId) ||
1004                            (tasksProposal.getClassPK() == null) ||
1005                            !tasksProposal.getClassPK().equals(classPK)) {
1006                        FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_C,
1007                            finderArgs, tasksProposal);
1008                    }
1009                }
1010
1011                return tasksProposal;
1012            }
1013            catch (Exception e) {
1014                throw processException(e);
1015            }
1016            finally {
1017                if (result == null) {
1018                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_C,
1019                        finderArgs, new ArrayList<TasksProposal>());
1020                }
1021
1022                closeSession(session);
1023            }
1024        }
1025        else {
1026            if (result instanceof List<?>) {
1027                return null;
1028            }
1029            else {
1030                return (TasksProposal)result;
1031            }
1032        }
1033    }
1034
1035    public List<TasksProposal> findAll() throws SystemException {
1036        return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1037    }
1038
1039    public List<TasksProposal> findAll(int start, int end)
1040        throws SystemException {
1041        return findAll(start, end, null);
1042    }
1043
1044    public List<TasksProposal> findAll(int start, int end,
1045        OrderByComparator orderByComparator) throws SystemException {
1046        Object[] finderArgs = new Object[] {
1047                String.valueOf(start), String.valueOf(end),
1048                String.valueOf(orderByComparator)
1049            };
1050
1051        List<TasksProposal> list = (List<TasksProposal>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
1052                finderArgs, this);
1053
1054        if (list == null) {
1055            Session session = null;
1056
1057            try {
1058                session = openSession();
1059
1060                StringBundler query = null;
1061                String sql = null;
1062
1063                if (orderByComparator != null) {
1064                    query = new StringBundler(2 +
1065                            (orderByComparator.getOrderByFields().length * 3));
1066
1067                    query.append(_SQL_SELECT_TASKSPROPOSAL);
1068
1069                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1070                        orderByComparator);
1071
1072                    sql = query.toString();
1073                }
1074
1075                else {
1076                    sql = _SQL_SELECT_TASKSPROPOSAL.concat(TasksProposalModelImpl.ORDER_BY_JPQL);
1077                }
1078
1079                Query q = session.createQuery(sql);
1080
1081                if (orderByComparator == null) {
1082                    list = (List<TasksProposal>)QueryUtil.list(q, getDialect(),
1083                            start, end, false);
1084
1085                    Collections.sort(list);
1086                }
1087                else {
1088                    list = (List<TasksProposal>)QueryUtil.list(q, getDialect(),
1089                            start, end);
1090                }
1091            }
1092            catch (Exception e) {
1093                throw processException(e);
1094            }
1095            finally {
1096                if (list == null) {
1097                    list = new ArrayList<TasksProposal>();
1098                }
1099
1100                cacheResult(list);
1101
1102                FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
1103
1104                closeSession(session);
1105            }
1106        }
1107
1108        return list;
1109    }
1110
1111    public void removeByGroupId(long groupId) throws SystemException {
1112        for (TasksProposal tasksProposal : findByGroupId(groupId)) {
1113            remove(tasksProposal);
1114        }
1115    }
1116
1117    public void removeByG_U(long groupId, long userId)
1118        throws SystemException {
1119        for (TasksProposal tasksProposal : findByG_U(groupId, userId)) {
1120            remove(tasksProposal);
1121        }
1122    }
1123
1124    public void removeByC_C(long classNameId, String classPK)
1125        throws NoSuchProposalException, SystemException {
1126        TasksProposal tasksProposal = findByC_C(classNameId, classPK);
1127
1128        remove(tasksProposal);
1129    }
1130
1131    public void removeAll() throws SystemException {
1132        for (TasksProposal tasksProposal : findAll()) {
1133            remove(tasksProposal);
1134        }
1135    }
1136
1137    public int countByGroupId(long groupId) throws SystemException {
1138        Object[] finderArgs = new Object[] { new Long(groupId) };
1139
1140        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_GROUPID,
1141                finderArgs, this);
1142
1143        if (count == null) {
1144            Session session = null;
1145
1146            try {
1147                session = openSession();
1148
1149                StringBundler query = new StringBundler(2);
1150
1151                query.append(_SQL_COUNT_TASKSPROPOSAL_WHERE);
1152
1153                query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1154
1155                String sql = query.toString();
1156
1157                Query q = session.createQuery(sql);
1158
1159                QueryPos qPos = QueryPos.getInstance(q);
1160
1161                qPos.add(groupId);
1162
1163                count = (Long)q.uniqueResult();
1164            }
1165            catch (Exception e) {
1166                throw processException(e);
1167            }
1168            finally {
1169                if (count == null) {
1170                    count = Long.valueOf(0);
1171                }
1172
1173                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_GROUPID,
1174                    finderArgs, count);
1175
1176                closeSession(session);
1177            }
1178        }
1179
1180        return count.intValue();
1181    }
1182
1183    public int countByG_U(long groupId, long userId) throws SystemException {
1184        Object[] finderArgs = new Object[] { new Long(groupId), new Long(userId) };
1185
1186        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_U,
1187                finderArgs, this);
1188
1189        if (count == null) {
1190            Session session = null;
1191
1192            try {
1193                session = openSession();
1194
1195                StringBundler query = new StringBundler(3);
1196
1197                query.append(_SQL_COUNT_TASKSPROPOSAL_WHERE);
1198
1199                query.append(_FINDER_COLUMN_G_U_GROUPID_2);
1200
1201                query.append(_FINDER_COLUMN_G_U_USERID_2);
1202
1203                String sql = query.toString();
1204
1205                Query q = session.createQuery(sql);
1206
1207                QueryPos qPos = QueryPos.getInstance(q);
1208
1209                qPos.add(groupId);
1210
1211                qPos.add(userId);
1212
1213                count = (Long)q.uniqueResult();
1214            }
1215            catch (Exception e) {
1216                throw processException(e);
1217            }
1218            finally {
1219                if (count == null) {
1220                    count = Long.valueOf(0);
1221                }
1222
1223                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_U, finderArgs,
1224                    count);
1225
1226                closeSession(session);
1227            }
1228        }
1229
1230        return count.intValue();
1231    }
1232
1233    public int countByC_C(long classNameId, String classPK)
1234        throws SystemException {
1235        Object[] finderArgs = new Object[] { new Long(classNameId), classPK };
1236
1237        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_C,
1238                finderArgs, this);
1239
1240        if (count == null) {
1241            Session session = null;
1242
1243            try {
1244                session = openSession();
1245
1246                StringBundler query = new StringBundler(3);
1247
1248                query.append(_SQL_COUNT_TASKSPROPOSAL_WHERE);
1249
1250                query.append(_FINDER_COLUMN_C_C_CLASSNAMEID_2);
1251
1252                if (classPK == null) {
1253                    query.append(_FINDER_COLUMN_C_C_CLASSPK_1);
1254                }
1255                else {
1256                    if (classPK.equals(StringPool.BLANK)) {
1257                        query.append(_FINDER_COLUMN_C_C_CLASSPK_3);
1258                    }
1259                    else {
1260                        query.append(_FINDER_COLUMN_C_C_CLASSPK_2);
1261                    }
1262                }
1263
1264                String sql = query.toString();
1265
1266                Query q = session.createQuery(sql);
1267
1268                QueryPos qPos = QueryPos.getInstance(q);
1269
1270                qPos.add(classNameId);
1271
1272                if (classPK != null) {
1273                    qPos.add(classPK);
1274                }
1275
1276                count = (Long)q.uniqueResult();
1277            }
1278            catch (Exception e) {
1279                throw processException(e);
1280            }
1281            finally {
1282                if (count == null) {
1283                    count = Long.valueOf(0);
1284                }
1285
1286                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_C, finderArgs,
1287                    count);
1288
1289                closeSession(session);
1290            }
1291        }
1292
1293        return count.intValue();
1294    }
1295
1296    public int countAll() throws SystemException {
1297        Object[] finderArgs = new Object[0];
1298
1299        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
1300                finderArgs, this);
1301
1302        if (count == null) {
1303            Session session = null;
1304
1305            try {
1306                session = openSession();
1307
1308                Query q = session.createQuery(_SQL_COUNT_TASKSPROPOSAL);
1309
1310                count = (Long)q.uniqueResult();
1311            }
1312            catch (Exception e) {
1313                throw processException(e);
1314            }
1315            finally {
1316                if (count == null) {
1317                    count = Long.valueOf(0);
1318                }
1319
1320                FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
1321                    count);
1322
1323                closeSession(session);
1324            }
1325        }
1326
1327        return count.intValue();
1328    }
1329
1330    public void afterPropertiesSet() {
1331        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
1332                    com.liferay.portal.util.PropsUtil.get(
1333                        "value.object.listener.com.liferay.portlet.tasks.model.TasksProposal")));
1334
1335        if (listenerClassNames.length > 0) {
1336            try {
1337                List<ModelListener<TasksProposal>> listenersList = new ArrayList<ModelListener<TasksProposal>>();
1338
1339                for (String listenerClassName : listenerClassNames) {
1340                    listenersList.add((ModelListener<TasksProposal>)Class.forName(
1341                            listenerClassName).newInstance());
1342                }
1343
1344                listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
1345            }
1346            catch (Exception e) {
1347                _log.error(e);
1348            }
1349        }
1350    }
1351
1352    @BeanReference(type = TasksProposalPersistence.class)
1353    protected TasksProposalPersistence tasksProposalPersistence;
1354    @BeanReference(type = TasksReviewPersistence.class)
1355    protected TasksReviewPersistence tasksReviewPersistence;
1356    @BeanReference(type = ResourcePersistence.class)
1357    protected ResourcePersistence resourcePersistence;
1358    @BeanReference(type = UserPersistence.class)
1359    protected UserPersistence userPersistence;
1360    @BeanReference(type = MBMessagePersistence.class)
1361    protected MBMessagePersistence mbMessagePersistence;
1362    @BeanReference(type = SocialActivityPersistence.class)
1363    protected SocialActivityPersistence socialActivityPersistence;
1364    private static final String _SQL_SELECT_TASKSPROPOSAL = "SELECT tasksProposal FROM TasksProposal tasksProposal";
1365    private static final String _SQL_SELECT_TASKSPROPOSAL_WHERE = "SELECT tasksProposal FROM TasksProposal tasksProposal WHERE ";
1366    private static final String _SQL_COUNT_TASKSPROPOSAL = "SELECT COUNT(tasksProposal) FROM TasksProposal tasksProposal";
1367    private static final String _SQL_COUNT_TASKSPROPOSAL_WHERE = "SELECT COUNT(tasksProposal) FROM TasksProposal tasksProposal WHERE ";
1368    private static final String _FINDER_COLUMN_GROUPID_GROUPID_2 = "tasksProposal.groupId = ?";
1369    private static final String _FINDER_COLUMN_G_U_GROUPID_2 = "tasksProposal.groupId = ? AND ";
1370    private static final String _FINDER_COLUMN_G_U_USERID_2 = "tasksProposal.userId = ?";
1371    private static final String _FINDER_COLUMN_C_C_CLASSNAMEID_2 = "tasksProposal.classNameId = ? AND ";
1372    private static final String _FINDER_COLUMN_C_C_CLASSPK_1 = "tasksProposal.classPK IS NULL";
1373    private static final String _FINDER_COLUMN_C_C_CLASSPK_2 = "tasksProposal.classPK = ?";
1374    private static final String _FINDER_COLUMN_C_C_CLASSPK_3 = "(tasksProposal.classPK IS NULL OR tasksProposal.classPK = ?)";
1375    private static final String _ORDER_BY_ENTITY_ALIAS = "tasksProposal.";
1376    private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No TasksProposal exists with the primary key ";
1377    private static final String _NO_SUCH_ENTITY_WITH_KEY = "No TasksProposal exists with the key {";
1378    private static Log _log = LogFactoryUtil.getLog(TasksProposalPersistenceImpl.class);
1379}