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