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