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