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