1   /**
2    * Copyright (c) 2000-2009 Liferay, Inc. All rights reserved.
3    *
4    * Permission is hereby granted, free of charge, to any person obtaining a copy
5    * of this software and associated documentation files (the "Software"), to deal
6    * in the Software without restriction, including without limitation the rights
7    * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8    * copies of the Software, and to permit persons to whom the Software is
9    * furnished to do so, subject to the following conditions:
10   *
11   * The above copyright notice and this permission notice shall be included in
12   * all copies or substantial portions of the Software.
13   *
14   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20   * SOFTWARE.
21   */
22  
23  package com.liferay.portlet.tasks.service.persistence;
24  
25  import com.liferay.portal.SystemException;
26  import com.liferay.portal.kernel.annotation.BeanReference;
27  import com.liferay.portal.kernel.cache.CacheRegistry;
28  import com.liferay.portal.kernel.dao.orm.DynamicQuery;
29  import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
30  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
31  import com.liferay.portal.kernel.dao.orm.FinderPath;
32  import com.liferay.portal.kernel.dao.orm.Query;
33  import com.liferay.portal.kernel.dao.orm.QueryPos;
34  import com.liferay.portal.kernel.dao.orm.QueryUtil;
35  import com.liferay.portal.kernel.dao.orm.Session;
36  import com.liferay.portal.kernel.log.Log;
37  import com.liferay.portal.kernel.log.LogFactoryUtil;
38  import com.liferay.portal.kernel.util.GetterUtil;
39  import com.liferay.portal.kernel.util.OrderByComparator;
40  import com.liferay.portal.kernel.util.StringPool;
41  import com.liferay.portal.kernel.util.StringUtil;
42  import com.liferay.portal.model.ModelListener;
43  import com.liferay.portal.service.persistence.BatchSessionUtil;
44  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
45  
46  import com.liferay.portlet.tasks.NoSuchReviewException;
47  import com.liferay.portlet.tasks.model.TasksReview;
48  import com.liferay.portlet.tasks.model.impl.TasksReviewImpl;
49  import com.liferay.portlet.tasks.model.impl.TasksReviewModelImpl;
50  
51  import java.util.ArrayList;
52  import java.util.Collections;
53  import java.util.List;
54  
55  /**
56   * <a href="TasksReviewPersistenceImpl.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       TasksReviewPersistence
65   * @see       TasksReviewUtil
66   * @generated
67   */
68  public class TasksReviewPersistenceImpl extends BasePersistenceImpl
69      implements TasksReviewPersistence {
70      public static final String FINDER_CLASS_NAME_ENTITY = TasksReviewImpl.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_USERID = new FinderPath(TasksReviewModelImpl.ENTITY_CACHE_ENABLED,
74              TasksReviewModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
75              "findByUserId", new String[] { Long.class.getName() });
76      public static final FinderPath FINDER_PATH_FIND_BY_OBC_USERID = new FinderPath(TasksReviewModelImpl.ENTITY_CACHE_ENABLED,
77              TasksReviewModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
78              "findByUserId",
79              new String[] {
80                  Long.class.getName(),
81                  
82              "java.lang.Integer", "java.lang.Integer",
83                  "com.liferay.portal.kernel.util.OrderByComparator"
84              });
85      public static final FinderPath FINDER_PATH_COUNT_BY_USERID = new FinderPath(TasksReviewModelImpl.ENTITY_CACHE_ENABLED,
86              TasksReviewModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
87              "countByUserId", new String[] { Long.class.getName() });
88      public static final FinderPath FINDER_PATH_FIND_BY_PROPOSALID = new FinderPath(TasksReviewModelImpl.ENTITY_CACHE_ENABLED,
89              TasksReviewModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
90              "findByProposalId", new String[] { Long.class.getName() });
91      public static final FinderPath FINDER_PATH_FIND_BY_OBC_PROPOSALID = new FinderPath(TasksReviewModelImpl.ENTITY_CACHE_ENABLED,
92              TasksReviewModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
93              "findByProposalId",
94              new String[] {
95                  Long.class.getName(),
96                  
97              "java.lang.Integer", "java.lang.Integer",
98                  "com.liferay.portal.kernel.util.OrderByComparator"
99              });
100     public static final FinderPath FINDER_PATH_COUNT_BY_PROPOSALID = new FinderPath(TasksReviewModelImpl.ENTITY_CACHE_ENABLED,
101             TasksReviewModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
102             "countByProposalId", new String[] { Long.class.getName() });
103     public static final FinderPath FINDER_PATH_FETCH_BY_U_P = new FinderPath(TasksReviewModelImpl.ENTITY_CACHE_ENABLED,
104             TasksReviewModelImpl.FINDER_CACHE_ENABLED,
105             FINDER_CLASS_NAME_ENTITY, "fetchByU_P",
106             new String[] { Long.class.getName(), Long.class.getName() });
107     public static final FinderPath FINDER_PATH_COUNT_BY_U_P = new FinderPath(TasksReviewModelImpl.ENTITY_CACHE_ENABLED,
108             TasksReviewModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
109             "countByU_P",
110             new String[] { Long.class.getName(), Long.class.getName() });
111     public static final FinderPath FINDER_PATH_FIND_BY_P_S = new FinderPath(TasksReviewModelImpl.ENTITY_CACHE_ENABLED,
112             TasksReviewModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
113             "findByP_S",
114             new String[] { Long.class.getName(), Integer.class.getName() });
115     public static final FinderPath FINDER_PATH_FIND_BY_OBC_P_S = new FinderPath(TasksReviewModelImpl.ENTITY_CACHE_ENABLED,
116             TasksReviewModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
117             "findByP_S",
118             new String[] {
119                 Long.class.getName(), Integer.class.getName(),
120                 
121             "java.lang.Integer", "java.lang.Integer",
122                 "com.liferay.portal.kernel.util.OrderByComparator"
123             });
124     public static final FinderPath FINDER_PATH_COUNT_BY_P_S = new FinderPath(TasksReviewModelImpl.ENTITY_CACHE_ENABLED,
125             TasksReviewModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
126             "countByP_S",
127             new String[] { Long.class.getName(), Integer.class.getName() });
128     public static final FinderPath FINDER_PATH_FIND_BY_P_S_C = new FinderPath(TasksReviewModelImpl.ENTITY_CACHE_ENABLED,
129             TasksReviewModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
130             "findByP_S_C",
131             new String[] {
132                 Long.class.getName(), Integer.class.getName(),
133                 Boolean.class.getName()
134             });
135     public static final FinderPath FINDER_PATH_FIND_BY_OBC_P_S_C = new FinderPath(TasksReviewModelImpl.ENTITY_CACHE_ENABLED,
136             TasksReviewModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
137             "findByP_S_C",
138             new String[] {
139                 Long.class.getName(), Integer.class.getName(),
140                 Boolean.class.getName(),
141                 
142             "java.lang.Integer", "java.lang.Integer",
143                 "com.liferay.portal.kernel.util.OrderByComparator"
144             });
145     public static final FinderPath FINDER_PATH_COUNT_BY_P_S_C = new FinderPath(TasksReviewModelImpl.ENTITY_CACHE_ENABLED,
146             TasksReviewModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
147             "countByP_S_C",
148             new String[] {
149                 Long.class.getName(), Integer.class.getName(),
150                 Boolean.class.getName()
151             });
152     public static final FinderPath FINDER_PATH_FIND_BY_P_S_C_R = new FinderPath(TasksReviewModelImpl.ENTITY_CACHE_ENABLED,
153             TasksReviewModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
154             "findByP_S_C_R",
155             new String[] {
156                 Long.class.getName(), Integer.class.getName(),
157                 Boolean.class.getName(), Boolean.class.getName()
158             });
159     public static final FinderPath FINDER_PATH_FIND_BY_OBC_P_S_C_R = new FinderPath(TasksReviewModelImpl.ENTITY_CACHE_ENABLED,
160             TasksReviewModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
161             "findByP_S_C_R",
162             new String[] {
163                 Long.class.getName(), Integer.class.getName(),
164                 Boolean.class.getName(), Boolean.class.getName(),
165                 
166             "java.lang.Integer", "java.lang.Integer",
167                 "com.liferay.portal.kernel.util.OrderByComparator"
168             });
169     public static final FinderPath FINDER_PATH_COUNT_BY_P_S_C_R = new FinderPath(TasksReviewModelImpl.ENTITY_CACHE_ENABLED,
170             TasksReviewModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
171             "countByP_S_C_R",
172             new String[] {
173                 Long.class.getName(), Integer.class.getName(),
174                 Boolean.class.getName(), Boolean.class.getName()
175             });
176     public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(TasksReviewModelImpl.ENTITY_CACHE_ENABLED,
177             TasksReviewModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
178             "findAll", new String[0]);
179     public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(TasksReviewModelImpl.ENTITY_CACHE_ENABLED,
180             TasksReviewModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
181             "countAll", new String[0]);
182 
183     public void cacheResult(TasksReview tasksReview) {
184         EntityCacheUtil.putResult(TasksReviewModelImpl.ENTITY_CACHE_ENABLED,
185             TasksReviewImpl.class, tasksReview.getPrimaryKey(), tasksReview);
186 
187         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_U_P,
188             new Object[] {
189                 new Long(tasksReview.getUserId()),
190                 new Long(tasksReview.getProposalId())
191             }, tasksReview);
192     }
193 
194     public void cacheResult(List<TasksReview> tasksReviews) {
195         for (TasksReview tasksReview : tasksReviews) {
196             if (EntityCacheUtil.getResult(
197                         TasksReviewModelImpl.ENTITY_CACHE_ENABLED,
198                         TasksReviewImpl.class, tasksReview.getPrimaryKey(), this) == null) {
199                 cacheResult(tasksReview);
200             }
201         }
202     }
203 
204     public void clearCache() {
205         CacheRegistry.clear(TasksReviewImpl.class.getName());
206         EntityCacheUtil.clearCache(TasksReviewImpl.class.getName());
207         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
208         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
209     }
210 
211     public TasksReview create(long reviewId) {
212         TasksReview tasksReview = new TasksReviewImpl();
213 
214         tasksReview.setNew(true);
215         tasksReview.setPrimaryKey(reviewId);
216 
217         return tasksReview;
218     }
219 
220     public TasksReview remove(long reviewId)
221         throws NoSuchReviewException, SystemException {
222         Session session = null;
223 
224         try {
225             session = openSession();
226 
227             TasksReview tasksReview = (TasksReview)session.get(TasksReviewImpl.class,
228                     new Long(reviewId));
229 
230             if (tasksReview == null) {
231                 if (_log.isWarnEnabled()) {
232                     _log.warn("No TasksReview exists with the primary key " +
233                         reviewId);
234                 }
235 
236                 throw new NoSuchReviewException(
237                     "No TasksReview exists with the primary key " + reviewId);
238             }
239 
240             return remove(tasksReview);
241         }
242         catch (NoSuchReviewException nsee) {
243             throw nsee;
244         }
245         catch (Exception e) {
246             throw processException(e);
247         }
248         finally {
249             closeSession(session);
250         }
251     }
252 
253     public TasksReview remove(TasksReview tasksReview)
254         throws SystemException {
255         for (ModelListener<TasksReview> listener : listeners) {
256             listener.onBeforeRemove(tasksReview);
257         }
258 
259         tasksReview = removeImpl(tasksReview);
260 
261         for (ModelListener<TasksReview> listener : listeners) {
262             listener.onAfterRemove(tasksReview);
263         }
264 
265         return tasksReview;
266     }
267 
268     protected TasksReview removeImpl(TasksReview tasksReview)
269         throws SystemException {
270         Session session = null;
271 
272         try {
273             session = openSession();
274 
275             if (tasksReview.isCachedModel() || BatchSessionUtil.isEnabled()) {
276                 Object staleObject = session.get(TasksReviewImpl.class,
277                         tasksReview.getPrimaryKeyObj());
278 
279                 if (staleObject != null) {
280                     session.evict(staleObject);
281                 }
282             }
283 
284             session.delete(tasksReview);
285 
286             session.flush();
287         }
288         catch (Exception e) {
289             throw processException(e);
290         }
291         finally {
292             closeSession(session);
293         }
294 
295         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
296 
297         TasksReviewModelImpl tasksReviewModelImpl = (TasksReviewModelImpl)tasksReview;
298 
299         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_U_P,
300             new Object[] {
301                 new Long(tasksReviewModelImpl.getOriginalUserId()),
302                 new Long(tasksReviewModelImpl.getOriginalProposalId())
303             });
304 
305         EntityCacheUtil.removeResult(TasksReviewModelImpl.ENTITY_CACHE_ENABLED,
306             TasksReviewImpl.class, tasksReview.getPrimaryKey());
307 
308         return tasksReview;
309     }
310 
311     /**
312      * @deprecated Use {@link #update(TasksReview, boolean merge)}.
313      */
314     public TasksReview update(TasksReview tasksReview)
315         throws SystemException {
316         if (_log.isWarnEnabled()) {
317             _log.warn(
318                 "Using the deprecated update(TasksReview tasksReview) method. Use update(TasksReview tasksReview, boolean merge) instead.");
319         }
320 
321         return update(tasksReview, false);
322     }
323 
324     /**
325      * Add, update, or merge, the entity. This method also calls the model
326      * listeners to trigger the proper events associated with adding, deleting,
327      * or updating an entity.
328      *
329      * @param  tasksReview the entity to add, update, or merge
330      * @param  merge boolean value for whether to merge the entity. The default
331      *         value is false. Setting merge to true is more expensive and
332      *         should only be true when tasksReview is transient. See
333      *         LEP-5473 for a detailed discussion of this method.
334      * @return the entity that was added, updated, or merged
335      */
336     public TasksReview update(TasksReview tasksReview, boolean merge)
337         throws SystemException {
338         boolean isNew = tasksReview.isNew();
339 
340         for (ModelListener<TasksReview> listener : listeners) {
341             if (isNew) {
342                 listener.onBeforeCreate(tasksReview);
343             }
344             else {
345                 listener.onBeforeUpdate(tasksReview);
346             }
347         }
348 
349         tasksReview = updateImpl(tasksReview, merge);
350 
351         for (ModelListener<TasksReview> listener : listeners) {
352             if (isNew) {
353                 listener.onAfterCreate(tasksReview);
354             }
355             else {
356                 listener.onAfterUpdate(tasksReview);
357             }
358         }
359 
360         return tasksReview;
361     }
362 
363     public TasksReview updateImpl(
364         com.liferay.portlet.tasks.model.TasksReview tasksReview, boolean merge)
365         throws SystemException {
366         boolean isNew = tasksReview.isNew();
367 
368         TasksReviewModelImpl tasksReviewModelImpl = (TasksReviewModelImpl)tasksReview;
369 
370         Session session = null;
371 
372         try {
373             session = openSession();
374 
375             BatchSessionUtil.update(session, tasksReview, merge);
376 
377             tasksReview.setNew(false);
378         }
379         catch (Exception e) {
380             throw processException(e);
381         }
382         finally {
383             closeSession(session);
384         }
385 
386         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
387 
388         EntityCacheUtil.putResult(TasksReviewModelImpl.ENTITY_CACHE_ENABLED,
389             TasksReviewImpl.class, tasksReview.getPrimaryKey(), tasksReview);
390 
391         if (!isNew &&
392                 ((tasksReview.getUserId() != tasksReviewModelImpl.getOriginalUserId()) ||
393                 (tasksReview.getProposalId() != tasksReviewModelImpl.getOriginalProposalId()))) {
394             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_U_P,
395                 new Object[] {
396                     new Long(tasksReviewModelImpl.getOriginalUserId()),
397                     new Long(tasksReviewModelImpl.getOriginalProposalId())
398                 });
399         }
400 
401         if (isNew ||
402                 ((tasksReview.getUserId() != tasksReviewModelImpl.getOriginalUserId()) ||
403                 (tasksReview.getProposalId() != tasksReviewModelImpl.getOriginalProposalId()))) {
404             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_U_P,
405                 new Object[] {
406                     new Long(tasksReview.getUserId()),
407                     new Long(tasksReview.getProposalId())
408                 }, tasksReview);
409         }
410 
411         return tasksReview;
412     }
413 
414     public TasksReview findByPrimaryKey(long reviewId)
415         throws NoSuchReviewException, SystemException {
416         TasksReview tasksReview = fetchByPrimaryKey(reviewId);
417 
418         if (tasksReview == null) {
419             if (_log.isWarnEnabled()) {
420                 _log.warn("No TasksReview exists with the primary key " +
421                     reviewId);
422             }
423 
424             throw new NoSuchReviewException(
425                 "No TasksReview exists with the primary key " + reviewId);
426         }
427 
428         return tasksReview;
429     }
430 
431     public TasksReview fetchByPrimaryKey(long reviewId)
432         throws SystemException {
433         TasksReview tasksReview = (TasksReview)EntityCacheUtil.getResult(TasksReviewModelImpl.ENTITY_CACHE_ENABLED,
434                 TasksReviewImpl.class, reviewId, this);
435 
436         if (tasksReview == null) {
437             Session session = null;
438 
439             try {
440                 session = openSession();
441 
442                 tasksReview = (TasksReview)session.get(TasksReviewImpl.class,
443                         new Long(reviewId));
444             }
445             catch (Exception e) {
446                 throw processException(e);
447             }
448             finally {
449                 if (tasksReview != null) {
450                     cacheResult(tasksReview);
451                 }
452 
453                 closeSession(session);
454             }
455         }
456 
457         return tasksReview;
458     }
459 
460     public List<TasksReview> findByUserId(long userId)
461         throws SystemException {
462         Object[] finderArgs = new Object[] { new Long(userId) };
463 
464         List<TasksReview> list = (List<TasksReview>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_USERID,
465                 finderArgs, this);
466 
467         if (list == null) {
468             Session session = null;
469 
470             try {
471                 session = openSession();
472 
473                 StringBuilder query = new StringBuilder();
474 
475                 query.append(
476                     "SELECT tasksReview FROM TasksReview tasksReview WHERE ");
477 
478                 query.append("tasksReview.userId = ?");
479 
480                 query.append(" ");
481 
482                 query.append("ORDER BY ");
483 
484                 query.append("tasksReview.createDate ASC");
485 
486                 Query q = session.createQuery(query.toString());
487 
488                 QueryPos qPos = QueryPos.getInstance(q);
489 
490                 qPos.add(userId);
491 
492                 list = q.list();
493             }
494             catch (Exception e) {
495                 throw processException(e);
496             }
497             finally {
498                 if (list == null) {
499                     list = new ArrayList<TasksReview>();
500                 }
501 
502                 cacheResult(list);
503 
504                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_USERID,
505                     finderArgs, list);
506 
507                 closeSession(session);
508             }
509         }
510 
511         return list;
512     }
513 
514     public List<TasksReview> findByUserId(long userId, int start, int end)
515         throws SystemException {
516         return findByUserId(userId, start, end, null);
517     }
518 
519     public List<TasksReview> findByUserId(long userId, int start, int end,
520         OrderByComparator obc) throws SystemException {
521         Object[] finderArgs = new Object[] {
522                 new Long(userId),
523                 
524                 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
525             };
526 
527         List<TasksReview> list = (List<TasksReview>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_USERID,
528                 finderArgs, this);
529 
530         if (list == null) {
531             Session session = null;
532 
533             try {
534                 session = openSession();
535 
536                 StringBuilder query = new StringBuilder();
537 
538                 query.append(
539                     "SELECT tasksReview FROM TasksReview tasksReview WHERE ");
540 
541                 query.append("tasksReview.userId = ?");
542 
543                 query.append(" ");
544 
545                 if (obc != null) {
546                     query.append("ORDER BY ");
547 
548                     String[] orderByFields = obc.getOrderByFields();
549 
550                     for (int i = 0; i < orderByFields.length; i++) {
551                         query.append("tasksReview.");
552                         query.append(orderByFields[i]);
553 
554                         if (obc.isAscending()) {
555                             query.append(" ASC");
556                         }
557                         else {
558                             query.append(" DESC");
559                         }
560 
561                         if ((i + 1) < orderByFields.length) {
562                             query.append(", ");
563                         }
564                     }
565                 }
566 
567                 else {
568                     query.append("ORDER BY ");
569 
570                     query.append("tasksReview.createDate ASC");
571                 }
572 
573                 Query q = session.createQuery(query.toString());
574 
575                 QueryPos qPos = QueryPos.getInstance(q);
576 
577                 qPos.add(userId);
578 
579                 list = (List<TasksReview>)QueryUtil.list(q, getDialect(),
580                         start, end);
581             }
582             catch (Exception e) {
583                 throw processException(e);
584             }
585             finally {
586                 if (list == null) {
587                     list = new ArrayList<TasksReview>();
588                 }
589 
590                 cacheResult(list);
591 
592                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_USERID,
593                     finderArgs, list);
594 
595                 closeSession(session);
596             }
597         }
598 
599         return list;
600     }
601 
602     public TasksReview findByUserId_First(long userId, OrderByComparator obc)
603         throws NoSuchReviewException, SystemException {
604         List<TasksReview> list = findByUserId(userId, 0, 1, obc);
605 
606         if (list.isEmpty()) {
607             StringBuilder msg = new StringBuilder();
608 
609             msg.append("No TasksReview exists with the key {");
610 
611             msg.append("userId=" + userId);
612 
613             msg.append(StringPool.CLOSE_CURLY_BRACE);
614 
615             throw new NoSuchReviewException(msg.toString());
616         }
617         else {
618             return list.get(0);
619         }
620     }
621 
622     public TasksReview findByUserId_Last(long userId, OrderByComparator obc)
623         throws NoSuchReviewException, SystemException {
624         int count = countByUserId(userId);
625 
626         List<TasksReview> list = findByUserId(userId, count - 1, count, obc);
627 
628         if (list.isEmpty()) {
629             StringBuilder msg = new StringBuilder();
630 
631             msg.append("No TasksReview exists with the key {");
632 
633             msg.append("userId=" + userId);
634 
635             msg.append(StringPool.CLOSE_CURLY_BRACE);
636 
637             throw new NoSuchReviewException(msg.toString());
638         }
639         else {
640             return list.get(0);
641         }
642     }
643 
644     public TasksReview[] findByUserId_PrevAndNext(long reviewId, long userId,
645         OrderByComparator obc) throws NoSuchReviewException, SystemException {
646         TasksReview tasksReview = findByPrimaryKey(reviewId);
647 
648         int count = countByUserId(userId);
649 
650         Session session = null;
651 
652         try {
653             session = openSession();
654 
655             StringBuilder query = new StringBuilder();
656 
657             query.append(
658                 "SELECT tasksReview FROM TasksReview tasksReview WHERE ");
659 
660             query.append("tasksReview.userId = ?");
661 
662             query.append(" ");
663 
664             if (obc != null) {
665                 query.append("ORDER BY ");
666 
667                 String[] orderByFields = obc.getOrderByFields();
668 
669                 for (int i = 0; i < orderByFields.length; i++) {
670                     query.append("tasksReview.");
671                     query.append(orderByFields[i]);
672 
673                     if (obc.isAscending()) {
674                         query.append(" ASC");
675                     }
676                     else {
677                         query.append(" DESC");
678                     }
679 
680                     if ((i + 1) < orderByFields.length) {
681                         query.append(", ");
682                     }
683                 }
684             }
685 
686             else {
687                 query.append("ORDER BY ");
688 
689                 query.append("tasksReview.createDate ASC");
690             }
691 
692             Query q = session.createQuery(query.toString());
693 
694             QueryPos qPos = QueryPos.getInstance(q);
695 
696             qPos.add(userId);
697 
698             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
699                     tasksReview);
700 
701             TasksReview[] array = new TasksReviewImpl[3];
702 
703             array[0] = (TasksReview)objArray[0];
704             array[1] = (TasksReview)objArray[1];
705             array[2] = (TasksReview)objArray[2];
706 
707             return array;
708         }
709         catch (Exception e) {
710             throw processException(e);
711         }
712         finally {
713             closeSession(session);
714         }
715     }
716 
717     public List<TasksReview> findByProposalId(long proposalId)
718         throws SystemException {
719         Object[] finderArgs = new Object[] { new Long(proposalId) };
720 
721         List<TasksReview> list = (List<TasksReview>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_PROPOSALID,
722                 finderArgs, this);
723 
724         if (list == null) {
725             Session session = null;
726 
727             try {
728                 session = openSession();
729 
730                 StringBuilder query = new StringBuilder();
731 
732                 query.append(
733                     "SELECT tasksReview FROM TasksReview tasksReview WHERE ");
734 
735                 query.append("tasksReview.proposalId = ?");
736 
737                 query.append(" ");
738 
739                 query.append("ORDER BY ");
740 
741                 query.append("tasksReview.createDate ASC");
742 
743                 Query q = session.createQuery(query.toString());
744 
745                 QueryPos qPos = QueryPos.getInstance(q);
746 
747                 qPos.add(proposalId);
748 
749                 list = q.list();
750             }
751             catch (Exception e) {
752                 throw processException(e);
753             }
754             finally {
755                 if (list == null) {
756                     list = new ArrayList<TasksReview>();
757                 }
758 
759                 cacheResult(list);
760 
761                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_PROPOSALID,
762                     finderArgs, list);
763 
764                 closeSession(session);
765             }
766         }
767 
768         return list;
769     }
770 
771     public List<TasksReview> findByProposalId(long proposalId, int start,
772         int end) throws SystemException {
773         return findByProposalId(proposalId, start, end, null);
774     }
775 
776     public List<TasksReview> findByProposalId(long proposalId, int start,
777         int end, OrderByComparator obc) throws SystemException {
778         Object[] finderArgs = new Object[] {
779                 new Long(proposalId),
780                 
781                 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
782             };
783 
784         List<TasksReview> list = (List<TasksReview>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_PROPOSALID,
785                 finderArgs, this);
786 
787         if (list == null) {
788             Session session = null;
789 
790             try {
791                 session = openSession();
792 
793                 StringBuilder query = new StringBuilder();
794 
795                 query.append(
796                     "SELECT tasksReview FROM TasksReview tasksReview WHERE ");
797 
798                 query.append("tasksReview.proposalId = ?");
799 
800                 query.append(" ");
801 
802                 if (obc != null) {
803                     query.append("ORDER BY ");
804 
805                     String[] orderByFields = obc.getOrderByFields();
806 
807                     for (int i = 0; i < orderByFields.length; i++) {
808                         query.append("tasksReview.");
809                         query.append(orderByFields[i]);
810 
811                         if (obc.isAscending()) {
812                             query.append(" ASC");
813                         }
814                         else {
815                             query.append(" DESC");
816                         }
817 
818                         if ((i + 1) < orderByFields.length) {
819                             query.append(", ");
820                         }
821                     }
822                 }
823 
824                 else {
825                     query.append("ORDER BY ");
826 
827                     query.append("tasksReview.createDate ASC");
828                 }
829 
830                 Query q = session.createQuery(query.toString());
831 
832                 QueryPos qPos = QueryPos.getInstance(q);
833 
834                 qPos.add(proposalId);
835 
836                 list = (List<TasksReview>)QueryUtil.list(q, getDialect(),
837                         start, end);
838             }
839             catch (Exception e) {
840                 throw processException(e);
841             }
842             finally {
843                 if (list == null) {
844                     list = new ArrayList<TasksReview>();
845                 }
846 
847                 cacheResult(list);
848 
849                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_PROPOSALID,
850                     finderArgs, list);
851 
852                 closeSession(session);
853             }
854         }
855 
856         return list;
857     }
858 
859     public TasksReview findByProposalId_First(long proposalId,
860         OrderByComparator obc) throws NoSuchReviewException, SystemException {
861         List<TasksReview> list = findByProposalId(proposalId, 0, 1, obc);
862 
863         if (list.isEmpty()) {
864             StringBuilder msg = new StringBuilder();
865 
866             msg.append("No TasksReview exists with the key {");
867 
868             msg.append("proposalId=" + proposalId);
869 
870             msg.append(StringPool.CLOSE_CURLY_BRACE);
871 
872             throw new NoSuchReviewException(msg.toString());
873         }
874         else {
875             return list.get(0);
876         }
877     }
878 
879     public TasksReview findByProposalId_Last(long proposalId,
880         OrderByComparator obc) throws NoSuchReviewException, SystemException {
881         int count = countByProposalId(proposalId);
882 
883         List<TasksReview> list = findByProposalId(proposalId, count - 1, count,
884                 obc);
885 
886         if (list.isEmpty()) {
887             StringBuilder msg = new StringBuilder();
888 
889             msg.append("No TasksReview exists with the key {");
890 
891             msg.append("proposalId=" + proposalId);
892 
893             msg.append(StringPool.CLOSE_CURLY_BRACE);
894 
895             throw new NoSuchReviewException(msg.toString());
896         }
897         else {
898             return list.get(0);
899         }
900     }
901 
902     public TasksReview[] findByProposalId_PrevAndNext(long reviewId,
903         long proposalId, OrderByComparator obc)
904         throws NoSuchReviewException, SystemException {
905         TasksReview tasksReview = findByPrimaryKey(reviewId);
906 
907         int count = countByProposalId(proposalId);
908 
909         Session session = null;
910 
911         try {
912             session = openSession();
913 
914             StringBuilder query = new StringBuilder();
915 
916             query.append(
917                 "SELECT tasksReview FROM TasksReview tasksReview WHERE ");
918 
919             query.append("tasksReview.proposalId = ?");
920 
921             query.append(" ");
922 
923             if (obc != null) {
924                 query.append("ORDER BY ");
925 
926                 String[] orderByFields = obc.getOrderByFields();
927 
928                 for (int i = 0; i < orderByFields.length; i++) {
929                     query.append("tasksReview.");
930                     query.append(orderByFields[i]);
931 
932                     if (obc.isAscending()) {
933                         query.append(" ASC");
934                     }
935                     else {
936                         query.append(" DESC");
937                     }
938 
939                     if ((i + 1) < orderByFields.length) {
940                         query.append(", ");
941                     }
942                 }
943             }
944 
945             else {
946                 query.append("ORDER BY ");
947 
948                 query.append("tasksReview.createDate ASC");
949             }
950 
951             Query q = session.createQuery(query.toString());
952 
953             QueryPos qPos = QueryPos.getInstance(q);
954 
955             qPos.add(proposalId);
956 
957             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
958                     tasksReview);
959 
960             TasksReview[] array = new TasksReviewImpl[3];
961 
962             array[0] = (TasksReview)objArray[0];
963             array[1] = (TasksReview)objArray[1];
964             array[2] = (TasksReview)objArray[2];
965 
966             return array;
967         }
968         catch (Exception e) {
969             throw processException(e);
970         }
971         finally {
972             closeSession(session);
973         }
974     }
975 
976     public TasksReview findByU_P(long userId, long proposalId)
977         throws NoSuchReviewException, SystemException {
978         TasksReview tasksReview = fetchByU_P(userId, proposalId);
979 
980         if (tasksReview == null) {
981             StringBuilder msg = new StringBuilder();
982 
983             msg.append("No TasksReview exists with the key {");
984 
985             msg.append("userId=" + userId);
986 
987             msg.append(", ");
988             msg.append("proposalId=" + proposalId);
989 
990             msg.append(StringPool.CLOSE_CURLY_BRACE);
991 
992             if (_log.isWarnEnabled()) {
993                 _log.warn(msg.toString());
994             }
995 
996             throw new NoSuchReviewException(msg.toString());
997         }
998 
999         return tasksReview;
1000    }
1001
1002    public TasksReview fetchByU_P(long userId, long proposalId)
1003        throws SystemException {
1004        return fetchByU_P(userId, proposalId, true);
1005    }
1006
1007    public TasksReview fetchByU_P(long userId, long proposalId,
1008        boolean retrieveFromCache) throws SystemException {
1009        Object[] finderArgs = new Object[] {
1010                new Long(userId), new Long(proposalId)
1011            };
1012
1013        Object result = null;
1014
1015        if (retrieveFromCache) {
1016            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_U_P,
1017                    finderArgs, this);
1018        }
1019
1020        if (result == null) {
1021            Session session = null;
1022
1023            try {
1024                session = openSession();
1025
1026                StringBuilder query = new StringBuilder();
1027
1028                query.append(
1029                    "SELECT tasksReview FROM TasksReview tasksReview WHERE ");
1030
1031                query.append("tasksReview.userId = ?");
1032
1033                query.append(" AND ");
1034
1035                query.append("tasksReview.proposalId = ?");
1036
1037                query.append(" ");
1038
1039                query.append("ORDER BY ");
1040
1041                query.append("tasksReview.createDate ASC");
1042
1043                Query q = session.createQuery(query.toString());
1044
1045                QueryPos qPos = QueryPos.getInstance(q);
1046
1047                qPos.add(userId);
1048
1049                qPos.add(proposalId);
1050
1051                List<TasksReview> list = q.list();
1052
1053                result = list;
1054
1055                TasksReview tasksReview = null;
1056
1057                if (list.isEmpty()) {
1058                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_U_P,
1059                        finderArgs, list);
1060                }
1061                else {
1062                    tasksReview = list.get(0);
1063
1064                    cacheResult(tasksReview);
1065
1066                    if ((tasksReview.getUserId() != userId) ||
1067                            (tasksReview.getProposalId() != proposalId)) {
1068                        FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_U_P,
1069                            finderArgs, tasksReview);
1070                    }
1071                }
1072
1073                return tasksReview;
1074            }
1075            catch (Exception e) {
1076                throw processException(e);
1077            }
1078            finally {
1079                if (result == null) {
1080                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_U_P,
1081                        finderArgs, new ArrayList<TasksReview>());
1082                }
1083
1084                closeSession(session);
1085            }
1086        }
1087        else {
1088            if (result instanceof List<?>) {
1089                return null;
1090            }
1091            else {
1092                return (TasksReview)result;
1093            }
1094        }
1095    }
1096
1097    public List<TasksReview> findByP_S(long proposalId, int stage)
1098        throws SystemException {
1099        Object[] finderArgs = new Object[] {
1100                new Long(proposalId), new Integer(stage)
1101            };
1102
1103        List<TasksReview> list = (List<TasksReview>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_P_S,
1104                finderArgs, this);
1105
1106        if (list == null) {
1107            Session session = null;
1108
1109            try {
1110                session = openSession();
1111
1112                StringBuilder query = new StringBuilder();
1113
1114                query.append(
1115                    "SELECT tasksReview FROM TasksReview tasksReview WHERE ");
1116
1117                query.append("tasksReview.proposalId = ?");
1118
1119                query.append(" AND ");
1120
1121                query.append("tasksReview.stage = ?");
1122
1123                query.append(" ");
1124
1125                query.append("ORDER BY ");
1126
1127                query.append("tasksReview.createDate ASC");
1128
1129                Query q = session.createQuery(query.toString());
1130
1131                QueryPos qPos = QueryPos.getInstance(q);
1132
1133                qPos.add(proposalId);
1134
1135                qPos.add(stage);
1136
1137                list = q.list();
1138            }
1139            catch (Exception e) {
1140                throw processException(e);
1141            }
1142            finally {
1143                if (list == null) {
1144                    list = new ArrayList<TasksReview>();
1145                }
1146
1147                cacheResult(list);
1148
1149                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_P_S, finderArgs,
1150                    list);
1151
1152                closeSession(session);
1153            }
1154        }
1155
1156        return list;
1157    }
1158
1159    public List<TasksReview> findByP_S(long proposalId, int stage, int start,
1160        int end) throws SystemException {
1161        return findByP_S(proposalId, stage, start, end, null);
1162    }
1163
1164    public List<TasksReview> findByP_S(long proposalId, int stage, int start,
1165        int end, OrderByComparator obc) throws SystemException {
1166        Object[] finderArgs = new Object[] {
1167                new Long(proposalId), new Integer(stage),
1168                
1169                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1170            };
1171
1172        List<TasksReview> list = (List<TasksReview>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_P_S,
1173                finderArgs, this);
1174
1175        if (list == null) {
1176            Session session = null;
1177
1178            try {
1179                session = openSession();
1180
1181                StringBuilder query = new StringBuilder();
1182
1183                query.append(
1184                    "SELECT tasksReview FROM TasksReview tasksReview WHERE ");
1185
1186                query.append("tasksReview.proposalId = ?");
1187
1188                query.append(" AND ");
1189
1190                query.append("tasksReview.stage = ?");
1191
1192                query.append(" ");
1193
1194                if (obc != null) {
1195                    query.append("ORDER BY ");
1196
1197                    String[] orderByFields = obc.getOrderByFields();
1198
1199                    for (int i = 0; i < orderByFields.length; i++) {
1200                        query.append("tasksReview.");
1201                        query.append(orderByFields[i]);
1202
1203                        if (obc.isAscending()) {
1204                            query.append(" ASC");
1205                        }
1206                        else {
1207                            query.append(" DESC");
1208                        }
1209
1210                        if ((i + 1) < orderByFields.length) {
1211                            query.append(", ");
1212                        }
1213                    }
1214                }
1215
1216                else {
1217                    query.append("ORDER BY ");
1218
1219                    query.append("tasksReview.createDate ASC");
1220                }
1221
1222                Query q = session.createQuery(query.toString());
1223
1224                QueryPos qPos = QueryPos.getInstance(q);
1225
1226                qPos.add(proposalId);
1227
1228                qPos.add(stage);
1229
1230                list = (List<TasksReview>)QueryUtil.list(q, getDialect(),
1231                        start, end);
1232            }
1233            catch (Exception e) {
1234                throw processException(e);
1235            }
1236            finally {
1237                if (list == null) {
1238                    list = new ArrayList<TasksReview>();
1239                }
1240
1241                cacheResult(list);
1242
1243                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_P_S,
1244                    finderArgs, list);
1245
1246                closeSession(session);
1247            }
1248        }
1249
1250        return list;
1251    }
1252
1253    public TasksReview findByP_S_First(long proposalId, int stage,
1254        OrderByComparator obc) throws NoSuchReviewException, SystemException {
1255        List<TasksReview> list = findByP_S(proposalId, stage, 0, 1, obc);
1256
1257        if (list.isEmpty()) {
1258            StringBuilder msg = new StringBuilder();
1259
1260            msg.append("No TasksReview exists with the key {");
1261
1262            msg.append("proposalId=" + proposalId);
1263
1264            msg.append(", ");
1265            msg.append("stage=" + stage);
1266
1267            msg.append(StringPool.CLOSE_CURLY_BRACE);
1268
1269            throw new NoSuchReviewException(msg.toString());
1270        }
1271        else {
1272            return list.get(0);
1273        }
1274    }
1275
1276    public TasksReview findByP_S_Last(long proposalId, int stage,
1277        OrderByComparator obc) throws NoSuchReviewException, SystemException {
1278        int count = countByP_S(proposalId, stage);
1279
1280        List<TasksReview> list = findByP_S(proposalId, stage, count - 1, count,
1281                obc);
1282
1283        if (list.isEmpty()) {
1284            StringBuilder msg = new StringBuilder();
1285
1286            msg.append("No TasksReview exists with the key {");
1287
1288            msg.append("proposalId=" + proposalId);
1289
1290            msg.append(", ");
1291            msg.append("stage=" + stage);
1292
1293            msg.append(StringPool.CLOSE_CURLY_BRACE);
1294
1295            throw new NoSuchReviewException(msg.toString());
1296        }
1297        else {
1298            return list.get(0);
1299        }
1300    }
1301
1302    public TasksReview[] findByP_S_PrevAndNext(long reviewId, long proposalId,
1303        int stage, OrderByComparator obc)
1304        throws NoSuchReviewException, SystemException {
1305        TasksReview tasksReview = findByPrimaryKey(reviewId);
1306
1307        int count = countByP_S(proposalId, stage);
1308
1309        Session session = null;
1310
1311        try {
1312            session = openSession();
1313
1314            StringBuilder query = new StringBuilder();
1315
1316            query.append(
1317                "SELECT tasksReview FROM TasksReview tasksReview WHERE ");
1318
1319            query.append("tasksReview.proposalId = ?");
1320
1321            query.append(" AND ");
1322
1323            query.append("tasksReview.stage = ?");
1324
1325            query.append(" ");
1326
1327            if (obc != null) {
1328                query.append("ORDER BY ");
1329
1330                String[] orderByFields = obc.getOrderByFields();
1331
1332                for (int i = 0; i < orderByFields.length; i++) {
1333                    query.append("tasksReview.");
1334                    query.append(orderByFields[i]);
1335
1336                    if (obc.isAscending()) {
1337                        query.append(" ASC");
1338                    }
1339                    else {
1340                        query.append(" DESC");
1341                    }
1342
1343                    if ((i + 1) < orderByFields.length) {
1344                        query.append(", ");
1345                    }
1346                }
1347            }
1348
1349            else {
1350                query.append("ORDER BY ");
1351
1352                query.append("tasksReview.createDate ASC");
1353            }
1354
1355            Query q = session.createQuery(query.toString());
1356
1357            QueryPos qPos = QueryPos.getInstance(q);
1358
1359            qPos.add(proposalId);
1360
1361            qPos.add(stage);
1362
1363            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1364                    tasksReview);
1365
1366            TasksReview[] array = new TasksReviewImpl[3];
1367
1368            array[0] = (TasksReview)objArray[0];
1369            array[1] = (TasksReview)objArray[1];
1370            array[2] = (TasksReview)objArray[2];
1371
1372            return array;
1373        }
1374        catch (Exception e) {
1375            throw processException(e);
1376        }
1377        finally {
1378            closeSession(session);
1379        }
1380    }
1381
1382    public List<TasksReview> findByP_S_C(long proposalId, int stage,
1383        boolean completed) throws SystemException {
1384        Object[] finderArgs = new Object[] {
1385                new Long(proposalId), new Integer(stage),
1386                Boolean.valueOf(completed)
1387            };
1388
1389        List<TasksReview> list = (List<TasksReview>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_P_S_C,
1390                finderArgs, this);
1391
1392        if (list == null) {
1393            Session session = null;
1394
1395            try {
1396                session = openSession();
1397
1398                StringBuilder query = new StringBuilder();
1399
1400                query.append(
1401                    "SELECT tasksReview FROM TasksReview tasksReview WHERE ");
1402
1403                query.append("tasksReview.proposalId = ?");
1404
1405                query.append(" AND ");
1406
1407                query.append("tasksReview.stage = ?");
1408
1409                query.append(" AND ");
1410
1411                query.append("tasksReview.completed = ?");
1412
1413                query.append(" ");
1414
1415                query.append("ORDER BY ");
1416
1417                query.append("tasksReview.createDate ASC");
1418
1419                Query q = session.createQuery(query.toString());
1420
1421                QueryPos qPos = QueryPos.getInstance(q);
1422
1423                qPos.add(proposalId);
1424
1425                qPos.add(stage);
1426
1427                qPos.add(completed);
1428
1429                list = q.list();
1430            }
1431            catch (Exception e) {
1432                throw processException(e);
1433            }
1434            finally {
1435                if (list == null) {
1436                    list = new ArrayList<TasksReview>();
1437                }
1438
1439                cacheResult(list);
1440
1441                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_P_S_C,
1442                    finderArgs, list);
1443
1444                closeSession(session);
1445            }
1446        }
1447
1448        return list;
1449    }
1450
1451    public List<TasksReview> findByP_S_C(long proposalId, int stage,
1452        boolean completed, int start, int end) throws SystemException {
1453        return findByP_S_C(proposalId, stage, completed, start, end, null);
1454    }
1455
1456    public List<TasksReview> findByP_S_C(long proposalId, int stage,
1457        boolean completed, int start, int end, OrderByComparator obc)
1458        throws SystemException {
1459        Object[] finderArgs = new Object[] {
1460                new Long(proposalId), new Integer(stage),
1461                Boolean.valueOf(completed),
1462                
1463                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1464            };
1465
1466        List<TasksReview> list = (List<TasksReview>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_P_S_C,
1467                finderArgs, this);
1468
1469        if (list == null) {
1470            Session session = null;
1471
1472            try {
1473                session = openSession();
1474
1475                StringBuilder query = new StringBuilder();
1476
1477                query.append(
1478                    "SELECT tasksReview FROM TasksReview tasksReview WHERE ");
1479
1480                query.append("tasksReview.proposalId = ?");
1481
1482                query.append(" AND ");
1483
1484                query.append("tasksReview.stage = ?");
1485
1486                query.append(" AND ");
1487
1488                query.append("tasksReview.completed = ?");
1489
1490                query.append(" ");
1491
1492                if (obc != null) {
1493                    query.append("ORDER BY ");
1494
1495                    String[] orderByFields = obc.getOrderByFields();
1496
1497                    for (int i = 0; i < orderByFields.length; i++) {
1498                        query.append("tasksReview.");
1499                        query.append(orderByFields[i]);
1500
1501                        if (obc.isAscending()) {
1502                            query.append(" ASC");
1503                        }
1504                        else {
1505                            query.append(" DESC");
1506                        }
1507
1508                        if ((i + 1) < orderByFields.length) {
1509                            query.append(", ");
1510                        }
1511                    }
1512                }
1513
1514                else {
1515                    query.append("ORDER BY ");
1516
1517                    query.append("tasksReview.createDate ASC");
1518                }
1519
1520                Query q = session.createQuery(query.toString());
1521
1522                QueryPos qPos = QueryPos.getInstance(q);
1523
1524                qPos.add(proposalId);
1525
1526                qPos.add(stage);
1527
1528                qPos.add(completed);
1529
1530                list = (List<TasksReview>)QueryUtil.list(q, getDialect(),
1531                        start, end);
1532            }
1533            catch (Exception e) {
1534                throw processException(e);
1535            }
1536            finally {
1537                if (list == null) {
1538                    list = new ArrayList<TasksReview>();
1539                }
1540
1541                cacheResult(list);
1542
1543                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_P_S_C,
1544                    finderArgs, list);
1545
1546                closeSession(session);
1547            }
1548        }
1549
1550        return list;
1551    }
1552
1553    public TasksReview findByP_S_C_First(long proposalId, int stage,
1554        boolean completed, OrderByComparator obc)
1555        throws NoSuchReviewException, SystemException {
1556        List<TasksReview> list = findByP_S_C(proposalId, stage, completed, 0,
1557                1, obc);
1558
1559        if (list.isEmpty()) {
1560            StringBuilder msg = new StringBuilder();
1561
1562            msg.append("No TasksReview exists with the key {");
1563
1564            msg.append("proposalId=" + proposalId);
1565
1566            msg.append(", ");
1567            msg.append("stage=" + stage);
1568
1569            msg.append(", ");
1570            msg.append("completed=" + completed);
1571
1572            msg.append(StringPool.CLOSE_CURLY_BRACE);
1573
1574            throw new NoSuchReviewException(msg.toString());
1575        }
1576        else {
1577            return list.get(0);
1578        }
1579    }
1580
1581    public TasksReview findByP_S_C_Last(long proposalId, int stage,
1582        boolean completed, OrderByComparator obc)
1583        throws NoSuchReviewException, SystemException {
1584        int count = countByP_S_C(proposalId, stage, completed);
1585
1586        List<TasksReview> list = findByP_S_C(proposalId, stage, completed,
1587                count - 1, count, obc);
1588
1589        if (list.isEmpty()) {
1590            StringBuilder msg = new StringBuilder();
1591
1592            msg.append("No TasksReview exists with the key {");
1593
1594            msg.append("proposalId=" + proposalId);
1595
1596            msg.append(", ");
1597            msg.append("stage=" + stage);
1598
1599            msg.append(", ");
1600            msg.append("completed=" + completed);
1601
1602            msg.append(StringPool.CLOSE_CURLY_BRACE);
1603
1604            throw new NoSuchReviewException(msg.toString());
1605        }
1606        else {
1607            return list.get(0);
1608        }
1609    }
1610
1611    public TasksReview[] findByP_S_C_PrevAndNext(long reviewId,
1612        long proposalId, int stage, boolean completed, OrderByComparator obc)
1613        throws NoSuchReviewException, SystemException {
1614        TasksReview tasksReview = findByPrimaryKey(reviewId);
1615
1616        int count = countByP_S_C(proposalId, stage, completed);
1617
1618        Session session = null;
1619
1620        try {
1621            session = openSession();
1622
1623            StringBuilder query = new StringBuilder();
1624
1625            query.append(
1626                "SELECT tasksReview FROM TasksReview tasksReview WHERE ");
1627
1628            query.append("tasksReview.proposalId = ?");
1629
1630            query.append(" AND ");
1631
1632            query.append("tasksReview.stage = ?");
1633
1634            query.append(" AND ");
1635
1636            query.append("tasksReview.completed = ?");
1637
1638            query.append(" ");
1639
1640            if (obc != null) {
1641                query.append("ORDER BY ");
1642
1643                String[] orderByFields = obc.getOrderByFields();
1644
1645                for (int i = 0; i < orderByFields.length; i++) {
1646                    query.append("tasksReview.");
1647                    query.append(orderByFields[i]);
1648
1649                    if (obc.isAscending()) {
1650                        query.append(" ASC");
1651                    }
1652                    else {
1653                        query.append(" DESC");
1654                    }
1655
1656                    if ((i + 1) < orderByFields.length) {
1657                        query.append(", ");
1658                    }
1659                }
1660            }
1661
1662            else {
1663                query.append("ORDER BY ");
1664
1665                query.append("tasksReview.createDate ASC");
1666            }
1667
1668            Query q = session.createQuery(query.toString());
1669
1670            QueryPos qPos = QueryPos.getInstance(q);
1671
1672            qPos.add(proposalId);
1673
1674            qPos.add(stage);
1675
1676            qPos.add(completed);
1677
1678            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1679                    tasksReview);
1680
1681            TasksReview[] array = new TasksReviewImpl[3];
1682
1683            array[0] = (TasksReview)objArray[0];
1684            array[1] = (TasksReview)objArray[1];
1685            array[2] = (TasksReview)objArray[2];
1686
1687            return array;
1688        }
1689        catch (Exception e) {
1690            throw processException(e);
1691        }
1692        finally {
1693            closeSession(session);
1694        }
1695    }
1696
1697    public List<TasksReview> findByP_S_C_R(long proposalId, int stage,
1698        boolean completed, boolean rejected) throws SystemException {
1699        Object[] finderArgs = new Object[] {
1700                new Long(proposalId), new Integer(stage),
1701                Boolean.valueOf(completed), Boolean.valueOf(rejected)
1702            };
1703
1704        List<TasksReview> list = (List<TasksReview>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_P_S_C_R,
1705                finderArgs, this);
1706
1707        if (list == null) {
1708            Session session = null;
1709
1710            try {
1711                session = openSession();
1712
1713                StringBuilder query = new StringBuilder();
1714
1715                query.append(
1716                    "SELECT tasksReview FROM TasksReview tasksReview WHERE ");
1717
1718                query.append("tasksReview.proposalId = ?");
1719
1720                query.append(" AND ");
1721
1722                query.append("tasksReview.stage = ?");
1723
1724                query.append(" AND ");
1725
1726                query.append("tasksReview.completed = ?");
1727
1728                query.append(" AND ");
1729
1730                query.append("tasksReview.rejected = ?");
1731
1732                query.append(" ");
1733
1734                query.append("ORDER BY ");
1735
1736                query.append("tasksReview.createDate ASC");
1737
1738                Query q = session.createQuery(query.toString());
1739
1740                QueryPos qPos = QueryPos.getInstance(q);
1741
1742                qPos.add(proposalId);
1743
1744                qPos.add(stage);
1745
1746                qPos.add(completed);
1747
1748                qPos.add(rejected);
1749
1750                list = q.list();
1751            }
1752            catch (Exception e) {
1753                throw processException(e);
1754            }
1755            finally {
1756                if (list == null) {
1757                    list = new ArrayList<TasksReview>();
1758                }
1759
1760                cacheResult(list);
1761
1762                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_P_S_C_R,
1763                    finderArgs, list);
1764
1765                closeSession(session);
1766            }
1767        }
1768
1769        return list;
1770    }
1771
1772    public List<TasksReview> findByP_S_C_R(long proposalId, int stage,
1773        boolean completed, boolean rejected, int start, int end)
1774        throws SystemException {
1775        return findByP_S_C_R(proposalId, stage, completed, rejected, start,
1776            end, null);
1777    }
1778
1779    public List<TasksReview> findByP_S_C_R(long proposalId, int stage,
1780        boolean completed, boolean rejected, int start, int end,
1781        OrderByComparator obc) throws SystemException {
1782        Object[] finderArgs = new Object[] {
1783                new Long(proposalId), new Integer(stage),
1784                Boolean.valueOf(completed), Boolean.valueOf(rejected),
1785                
1786                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1787            };
1788
1789        List<TasksReview> list = (List<TasksReview>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_P_S_C_R,
1790                finderArgs, this);
1791
1792        if (list == null) {
1793            Session session = null;
1794
1795            try {
1796                session = openSession();
1797
1798                StringBuilder query = new StringBuilder();
1799
1800                query.append(
1801                    "SELECT tasksReview FROM TasksReview tasksReview WHERE ");
1802
1803                query.append("tasksReview.proposalId = ?");
1804
1805                query.append(" AND ");
1806
1807                query.append("tasksReview.stage = ?");
1808
1809                query.append(" AND ");
1810
1811                query.append("tasksReview.completed = ?");
1812
1813                query.append(" AND ");
1814
1815                query.append("tasksReview.rejected = ?");
1816
1817                query.append(" ");
1818
1819                if (obc != null) {
1820                    query.append("ORDER BY ");
1821
1822                    String[] orderByFields = obc.getOrderByFields();
1823
1824                    for (int i = 0; i < orderByFields.length; i++) {
1825                        query.append("tasksReview.");
1826                        query.append(orderByFields[i]);
1827
1828                        if (obc.isAscending()) {
1829                            query.append(" ASC");
1830                        }
1831                        else {
1832                            query.append(" DESC");
1833                        }
1834
1835                        if ((i + 1) < orderByFields.length) {
1836                            query.append(", ");
1837                        }
1838                    }
1839                }
1840
1841                else {
1842                    query.append("ORDER BY ");
1843
1844                    query.append("tasksReview.createDate ASC");
1845                }
1846
1847                Query q = session.createQuery(query.toString());
1848
1849                QueryPos qPos = QueryPos.getInstance(q);
1850
1851                qPos.add(proposalId);
1852
1853                qPos.add(stage);
1854
1855                qPos.add(completed);
1856
1857                qPos.add(rejected);
1858
1859                list = (List<TasksReview>)QueryUtil.list(q, getDialect(),
1860                        start, end);
1861            }
1862            catch (Exception e) {
1863                throw processException(e);
1864            }
1865            finally {
1866                if (list == null) {
1867                    list = new ArrayList<TasksReview>();
1868                }
1869
1870                cacheResult(list);
1871
1872                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_P_S_C_R,
1873                    finderArgs, list);
1874
1875                closeSession(session);
1876            }
1877        }
1878
1879        return list;
1880    }
1881
1882    public TasksReview findByP_S_C_R_First(long proposalId, int stage,
1883        boolean completed, boolean rejected, OrderByComparator obc)
1884        throws NoSuchReviewException, SystemException {
1885        List<TasksReview> list = findByP_S_C_R(proposalId, stage, completed,
1886                rejected, 0, 1, obc);
1887
1888        if (list.isEmpty()) {
1889            StringBuilder msg = new StringBuilder();
1890
1891            msg.append("No TasksReview exists with the key {");
1892
1893            msg.append("proposalId=" + proposalId);
1894
1895            msg.append(", ");
1896            msg.append("stage=" + stage);
1897
1898            msg.append(", ");
1899            msg.append("completed=" + completed);
1900
1901            msg.append(", ");
1902            msg.append("rejected=" + rejected);
1903
1904            msg.append(StringPool.CLOSE_CURLY_BRACE);
1905
1906            throw new NoSuchReviewException(msg.toString());
1907        }
1908        else {
1909            return list.get(0);
1910        }
1911    }
1912
1913    public TasksReview findByP_S_C_R_Last(long proposalId, int stage,
1914        boolean completed, boolean rejected, OrderByComparator obc)
1915        throws NoSuchReviewException, SystemException {
1916        int count = countByP_S_C_R(proposalId, stage, completed, rejected);
1917
1918        List<TasksReview> list = findByP_S_C_R(proposalId, stage, completed,
1919                rejected, count - 1, count, obc);
1920
1921        if (list.isEmpty()) {
1922            StringBuilder msg = new StringBuilder();
1923
1924            msg.append("No TasksReview exists with the key {");
1925
1926            msg.append("proposalId=" + proposalId);
1927
1928            msg.append(", ");
1929            msg.append("stage=" + stage);
1930
1931            msg.append(", ");
1932            msg.append("completed=" + completed);
1933
1934            msg.append(", ");
1935            msg.append("rejected=" + rejected);
1936
1937            msg.append(StringPool.CLOSE_CURLY_BRACE);
1938
1939            throw new NoSuchReviewException(msg.toString());
1940        }
1941        else {
1942            return list.get(0);
1943        }
1944    }
1945
1946    public TasksReview[] findByP_S_C_R_PrevAndNext(long reviewId,
1947        long proposalId, int stage, boolean completed, boolean rejected,
1948        OrderByComparator obc) throws NoSuchReviewException, SystemException {
1949        TasksReview tasksReview = findByPrimaryKey(reviewId);
1950
1951        int count = countByP_S_C_R(proposalId, stage, completed, rejected);
1952
1953        Session session = null;
1954
1955        try {
1956            session = openSession();
1957
1958            StringBuilder query = new StringBuilder();
1959
1960            query.append(
1961                "SELECT tasksReview FROM TasksReview tasksReview WHERE ");
1962
1963            query.append("tasksReview.proposalId = ?");
1964
1965            query.append(" AND ");
1966
1967            query.append("tasksReview.stage = ?");
1968
1969            query.append(" AND ");
1970
1971            query.append("tasksReview.completed = ?");
1972
1973            query.append(" AND ");
1974
1975            query.append("tasksReview.rejected = ?");
1976
1977            query.append(" ");
1978
1979            if (obc != null) {
1980                query.append("ORDER BY ");
1981
1982                String[] orderByFields = obc.getOrderByFields();
1983
1984                for (int i = 0; i < orderByFields.length; i++) {
1985                    query.append("tasksReview.");
1986                    query.append(orderByFields[i]);
1987
1988                    if (obc.isAscending()) {
1989                        query.append(" ASC");
1990                    }
1991                    else {
1992                        query.append(" DESC");
1993                    }
1994
1995                    if ((i + 1) < orderByFields.length) {
1996                        query.append(", ");
1997                    }
1998                }
1999            }
2000
2001            else {
2002                query.append("ORDER BY ");
2003
2004                query.append("tasksReview.createDate ASC");
2005            }
2006
2007            Query q = session.createQuery(query.toString());
2008
2009            QueryPos qPos = QueryPos.getInstance(q);
2010
2011            qPos.add(proposalId);
2012
2013            qPos.add(stage);
2014
2015            qPos.add(completed);
2016
2017            qPos.add(rejected);
2018
2019            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
2020                    tasksReview);
2021
2022            TasksReview[] array = new TasksReviewImpl[3];
2023
2024            array[0] = (TasksReview)objArray[0];
2025            array[1] = (TasksReview)objArray[1];
2026            array[2] = (TasksReview)objArray[2];
2027
2028            return array;
2029        }
2030        catch (Exception e) {
2031            throw processException(e);
2032        }
2033        finally {
2034            closeSession(session);
2035        }
2036    }
2037
2038    public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery)
2039        throws SystemException {
2040        Session session = null;
2041
2042        try {
2043            session = openSession();
2044
2045            dynamicQuery.compile(session);
2046
2047            return dynamicQuery.list();
2048        }
2049        catch (Exception e) {
2050            throw processException(e);
2051        }
2052        finally {
2053            closeSession(session);
2054        }
2055    }
2056
2057    public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery,
2058        int start, int end) throws SystemException {
2059        Session session = null;
2060
2061        try {
2062            session = openSession();
2063
2064            dynamicQuery.setLimit(start, end);
2065
2066            dynamicQuery.compile(session);
2067
2068            return dynamicQuery.list();
2069        }
2070        catch (Exception e) {
2071            throw processException(e);
2072        }
2073        finally {
2074            closeSession(session);
2075        }
2076    }
2077
2078    public List<TasksReview> findAll() throws SystemException {
2079        return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
2080    }
2081
2082    public List<TasksReview> findAll(int start, int end)
2083        throws SystemException {
2084        return findAll(start, end, null);
2085    }
2086
2087    public List<TasksReview> findAll(int start, int end, OrderByComparator obc)
2088        throws SystemException {
2089        Object[] finderArgs = new Object[] {
2090                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
2091            };
2092
2093        List<TasksReview> list = (List<TasksReview>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
2094                finderArgs, this);
2095
2096        if (list == null) {
2097            Session session = null;
2098
2099            try {
2100                session = openSession();
2101
2102                StringBuilder query = new StringBuilder();
2103
2104                query.append("SELECT tasksReview FROM TasksReview tasksReview ");
2105
2106                if (obc != null) {
2107                    query.append("ORDER BY ");
2108
2109                    String[] orderByFields = obc.getOrderByFields();
2110
2111                    for (int i = 0; i < orderByFields.length; i++) {
2112                        query.append("tasksReview.");
2113                        query.append(orderByFields[i]);
2114
2115                        if (obc.isAscending()) {
2116                            query.append(" ASC");
2117                        }
2118                        else {
2119                            query.append(" DESC");
2120                        }
2121
2122                        if ((i + 1) < orderByFields.length) {
2123                            query.append(", ");
2124                        }
2125                    }
2126                }
2127
2128                else {
2129                    query.append("ORDER BY ");
2130
2131                    query.append("tasksReview.createDate ASC");
2132                }
2133
2134                Query q = session.createQuery(query.toString());
2135
2136                if (obc == null) {
2137                    list = (List<TasksReview>)QueryUtil.list(q, getDialect(),
2138                            start, end, false);
2139
2140                    Collections.sort(list);
2141                }
2142                else {
2143                    list = (List<TasksReview>)QueryUtil.list(q, getDialect(),
2144                            start, end);
2145                }
2146            }
2147            catch (Exception e) {
2148                throw processException(e);
2149            }
2150            finally {
2151                if (list == null) {
2152                    list = new ArrayList<TasksReview>();
2153                }
2154
2155                cacheResult(list);
2156
2157                FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
2158
2159                closeSession(session);
2160            }
2161        }
2162
2163        return list;
2164    }
2165
2166    public void removeByUserId(long userId) throws SystemException {
2167        for (TasksReview tasksReview : findByUserId(userId)) {
2168            remove(tasksReview);
2169        }
2170    }
2171
2172    public void removeByProposalId(long proposalId) throws SystemException {
2173        for (TasksReview tasksReview : findByProposalId(proposalId)) {
2174            remove(tasksReview);
2175        }
2176    }
2177
2178    public void removeByU_P(long userId, long proposalId)
2179        throws NoSuchReviewException, SystemException {
2180        TasksReview tasksReview = findByU_P(userId, proposalId);
2181
2182        remove(tasksReview);
2183    }
2184
2185    public void removeByP_S(long proposalId, int stage)
2186        throws SystemException {
2187        for (TasksReview tasksReview : findByP_S(proposalId, stage)) {
2188            remove(tasksReview);
2189        }
2190    }
2191
2192    public void removeByP_S_C(long proposalId, int stage, boolean completed)
2193        throws SystemException {
2194        for (TasksReview tasksReview : findByP_S_C(proposalId, stage, completed)) {
2195            remove(tasksReview);
2196        }
2197    }
2198
2199    public void removeByP_S_C_R(long proposalId, int stage, boolean completed,
2200        boolean rejected) throws SystemException {
2201        for (TasksReview tasksReview : findByP_S_C_R(proposalId, stage,
2202                completed, rejected)) {
2203            remove(tasksReview);
2204        }
2205    }
2206
2207    public void removeAll() throws SystemException {
2208        for (TasksReview tasksReview : findAll()) {
2209            remove(tasksReview);
2210        }
2211    }
2212
2213    public int countByUserId(long userId) throws SystemException {
2214        Object[] finderArgs = new Object[] { new Long(userId) };
2215
2216        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_USERID,
2217                finderArgs, this);
2218
2219        if (count == null) {
2220            Session session = null;
2221
2222            try {
2223                session = openSession();
2224
2225                StringBuilder query = new StringBuilder();
2226
2227                query.append("SELECT COUNT(tasksReview) ");
2228                query.append("FROM TasksReview tasksReview WHERE ");
2229
2230                query.append("tasksReview.userId = ?");
2231
2232                query.append(" ");
2233
2234                Query q = session.createQuery(query.toString());
2235
2236                QueryPos qPos = QueryPos.getInstance(q);
2237
2238                qPos.add(userId);
2239
2240                count = (Long)q.uniqueResult();
2241            }
2242            catch (Exception e) {
2243                throw processException(e);
2244            }
2245            finally {
2246                if (count == null) {
2247                    count = Long.valueOf(0);
2248                }
2249
2250                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_USERID,
2251                    finderArgs, count);
2252
2253                closeSession(session);
2254            }
2255        }
2256
2257        return count.intValue();
2258    }
2259
2260    public int countByProposalId(long proposalId) throws SystemException {
2261        Object[] finderArgs = new Object[] { new Long(proposalId) };
2262
2263        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_PROPOSALID,
2264                finderArgs, this);
2265
2266        if (count == null) {
2267            Session session = null;
2268
2269            try {
2270                session = openSession();
2271
2272                StringBuilder query = new StringBuilder();
2273
2274                query.append("SELECT COUNT(tasksReview) ");
2275                query.append("FROM TasksReview tasksReview WHERE ");
2276
2277                query.append("tasksReview.proposalId = ?");
2278
2279                query.append(" ");
2280
2281                Query q = session.createQuery(query.toString());
2282
2283                QueryPos qPos = QueryPos.getInstance(q);
2284
2285                qPos.add(proposalId);
2286
2287                count = (Long)q.uniqueResult();
2288            }
2289            catch (Exception e) {
2290                throw processException(e);
2291            }
2292            finally {
2293                if (count == null) {
2294                    count = Long.valueOf(0);
2295                }
2296
2297                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_PROPOSALID,
2298                    finderArgs, count);
2299
2300                closeSession(session);
2301            }
2302        }
2303
2304        return count.intValue();
2305    }
2306
2307    public int countByU_P(long userId, long proposalId)
2308        throws SystemException {
2309        Object[] finderArgs = new Object[] {
2310                new Long(userId), new Long(proposalId)
2311            };
2312
2313        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_U_P,
2314                finderArgs, this);
2315
2316        if (count == null) {
2317            Session session = null;
2318
2319            try {
2320                session = openSession();
2321
2322                StringBuilder query = new StringBuilder();
2323
2324                query.append("SELECT COUNT(tasksReview) ");
2325                query.append("FROM TasksReview tasksReview WHERE ");
2326
2327                query.append("tasksReview.userId = ?");
2328
2329                query.append(" AND ");
2330
2331                query.append("tasksReview.proposalId = ?");
2332
2333                query.append(" ");
2334
2335                Query q = session.createQuery(query.toString());
2336
2337                QueryPos qPos = QueryPos.getInstance(q);
2338
2339                qPos.add(userId);
2340
2341                qPos.add(proposalId);
2342
2343                count = (Long)q.uniqueResult();
2344            }
2345            catch (Exception e) {
2346                throw processException(e);
2347            }
2348            finally {
2349                if (count == null) {
2350                    count = Long.valueOf(0);
2351                }
2352
2353                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_U_P, finderArgs,
2354                    count);
2355
2356                closeSession(session);
2357            }
2358        }
2359
2360        return count.intValue();
2361    }
2362
2363    public int countByP_S(long proposalId, int stage) throws SystemException {
2364        Object[] finderArgs = new Object[] {
2365                new Long(proposalId), new Integer(stage)
2366            };
2367
2368        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_P_S,
2369                finderArgs, this);
2370
2371        if (count == null) {
2372            Session session = null;
2373
2374            try {
2375                session = openSession();
2376
2377                StringBuilder query = new StringBuilder();
2378
2379                query.append("SELECT COUNT(tasksReview) ");
2380                query.append("FROM TasksReview tasksReview WHERE ");
2381
2382                query.append("tasksReview.proposalId = ?");
2383
2384                query.append(" AND ");
2385
2386                query.append("tasksReview.stage = ?");
2387
2388                query.append(" ");
2389
2390                Query q = session.createQuery(query.toString());
2391
2392                QueryPos qPos = QueryPos.getInstance(q);
2393
2394                qPos.add(proposalId);
2395
2396                qPos.add(stage);
2397
2398                count = (Long)q.uniqueResult();
2399            }
2400            catch (Exception e) {
2401                throw processException(e);
2402            }
2403            finally {
2404                if (count == null) {
2405                    count = Long.valueOf(0);
2406                }
2407
2408                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_P_S, finderArgs,
2409                    count);
2410
2411                closeSession(session);
2412            }
2413        }
2414
2415        return count.intValue();
2416    }
2417
2418    public int countByP_S_C(long proposalId, int stage, boolean completed)
2419        throws SystemException {
2420        Object[] finderArgs = new Object[] {
2421                new Long(proposalId), new Integer(stage),
2422                Boolean.valueOf(completed)
2423            };
2424
2425        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_P_S_C,
2426                finderArgs, this);
2427
2428        if (count == null) {
2429            Session session = null;
2430
2431            try {
2432                session = openSession();
2433
2434                StringBuilder query = new StringBuilder();
2435
2436                query.append("SELECT COUNT(tasksReview) ");
2437                query.append("FROM TasksReview tasksReview WHERE ");
2438
2439                query.append("tasksReview.proposalId = ?");
2440
2441                query.append(" AND ");
2442
2443                query.append("tasksReview.stage = ?");
2444
2445                query.append(" AND ");
2446
2447                query.append("tasksReview.completed = ?");
2448
2449                query.append(" ");
2450
2451                Query q = session.createQuery(query.toString());
2452
2453                QueryPos qPos = QueryPos.getInstance(q);
2454
2455                qPos.add(proposalId);
2456
2457                qPos.add(stage);
2458
2459                qPos.add(completed);
2460
2461                count = (Long)q.uniqueResult();
2462            }
2463            catch (Exception e) {
2464                throw processException(e);
2465            }
2466            finally {
2467                if (count == null) {
2468                    count = Long.valueOf(0);
2469                }
2470
2471                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_P_S_C,
2472                    finderArgs, count);
2473
2474                closeSession(session);
2475            }
2476        }
2477
2478        return count.intValue();
2479    }
2480
2481    public int countByP_S_C_R(long proposalId, int stage, boolean completed,
2482        boolean rejected) throws SystemException {
2483        Object[] finderArgs = new Object[] {
2484                new Long(proposalId), new Integer(stage),
2485                Boolean.valueOf(completed), Boolean.valueOf(rejected)
2486            };
2487
2488        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_P_S_C_R,
2489                finderArgs, this);
2490
2491        if (count == null) {
2492            Session session = null;
2493
2494            try {
2495                session = openSession();
2496
2497                StringBuilder query = new StringBuilder();
2498
2499                query.append("SELECT COUNT(tasksReview) ");
2500                query.append("FROM TasksReview tasksReview WHERE ");
2501
2502                query.append("tasksReview.proposalId = ?");
2503
2504                query.append(" AND ");
2505
2506                query.append("tasksReview.stage = ?");
2507
2508                query.append(" AND ");
2509
2510                query.append("tasksReview.completed = ?");
2511
2512                query.append(" AND ");
2513
2514                query.append("tasksReview.rejected = ?");
2515
2516                query.append(" ");
2517
2518                Query q = session.createQuery(query.toString());
2519
2520                QueryPos qPos = QueryPos.getInstance(q);
2521
2522                qPos.add(proposalId);
2523
2524                qPos.add(stage);
2525
2526                qPos.add(completed);
2527
2528                qPos.add(rejected);
2529
2530                count = (Long)q.uniqueResult();
2531            }
2532            catch (Exception e) {
2533                throw processException(e);
2534            }
2535            finally {
2536                if (count == null) {
2537                    count = Long.valueOf(0);
2538                }
2539
2540                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_P_S_C_R,
2541                    finderArgs, count);
2542
2543                closeSession(session);
2544            }
2545        }
2546
2547        return count.intValue();
2548    }
2549
2550    public int countAll() throws SystemException {
2551        Object[] finderArgs = new Object[0];
2552
2553        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
2554                finderArgs, this);
2555
2556        if (count == null) {
2557            Session session = null;
2558
2559            try {
2560                session = openSession();
2561
2562                Query q = session.createQuery(
2563                        "SELECT COUNT(tasksReview) FROM TasksReview tasksReview");
2564
2565                count = (Long)q.uniqueResult();
2566            }
2567            catch (Exception e) {
2568                throw processException(e);
2569            }
2570            finally {
2571                if (count == null) {
2572                    count = Long.valueOf(0);
2573                }
2574
2575                FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
2576                    count);
2577
2578                closeSession(session);
2579            }
2580        }
2581
2582        return count.intValue();
2583    }
2584
2585    public void afterPropertiesSet() {
2586        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
2587                    com.liferay.portal.util.PropsUtil.get(
2588                        "value.object.listener.com.liferay.portlet.tasks.model.TasksReview")));
2589
2590        if (listenerClassNames.length > 0) {
2591            try {
2592                List<ModelListener<TasksReview>> listenersList = new ArrayList<ModelListener<TasksReview>>();
2593
2594                for (String listenerClassName : listenerClassNames) {
2595                    listenersList.add((ModelListener<TasksReview>)Class.forName(
2596                            listenerClassName).newInstance());
2597                }
2598
2599                listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
2600            }
2601            catch (Exception e) {
2602                _log.error(e);
2603            }
2604        }
2605    }
2606
2607    @BeanReference(name = "com.liferay.portlet.tasks.service.persistence.TasksProposalPersistence.impl")
2608    protected com.liferay.portlet.tasks.service.persistence.TasksProposalPersistence tasksProposalPersistence;
2609    @BeanReference(name = "com.liferay.portlet.tasks.service.persistence.TasksReviewPersistence.impl")
2610    protected com.liferay.portlet.tasks.service.persistence.TasksReviewPersistence tasksReviewPersistence;
2611    @BeanReference(name = "com.liferay.portal.service.persistence.ResourcePersistence.impl")
2612    protected com.liferay.portal.service.persistence.ResourcePersistence resourcePersistence;
2613    @BeanReference(name = "com.liferay.portal.service.persistence.UserPersistence.impl")
2614    protected com.liferay.portal.service.persistence.UserPersistence userPersistence;
2615    @BeanReference(name = "com.liferay.portlet.social.service.persistence.SocialActivityPersistence.impl")
2616    protected com.liferay.portlet.social.service.persistence.SocialActivityPersistence socialActivityPersistence;
2617    private static Log _log = LogFactoryUtil.getLog(TasksReviewPersistenceImpl.class);
2618}