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