1
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
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}