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