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