1
14
15 package com.liferay.portlet.blogs.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.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.model.ModelListener;
37 import com.liferay.portal.service.persistence.BatchSessionUtil;
38 import com.liferay.portal.service.persistence.GroupPersistence;
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.blogs.NoSuchStatsUserException;
44 import com.liferay.portlet.blogs.model.BlogsStatsUser;
45 import com.liferay.portlet.blogs.model.impl.BlogsStatsUserImpl;
46 import com.liferay.portlet.blogs.model.impl.BlogsStatsUserModelImpl;
47
48 import java.io.Serializable;
49
50 import java.util.ArrayList;
51 import java.util.Collections;
52 import java.util.List;
53
54
67 public class BlogsStatsUserPersistenceImpl extends BasePersistenceImpl<BlogsStatsUser>
68 implements BlogsStatsUserPersistence {
69 public static final String FINDER_CLASS_NAME_ENTITY = BlogsStatsUserImpl.class.getName();
70 public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
71 ".List";
72 public static final FinderPath FINDER_PATH_FIND_BY_GROUPID = new FinderPath(BlogsStatsUserModelImpl.ENTITY_CACHE_ENABLED,
73 BlogsStatsUserModelImpl.FINDER_CACHE_ENABLED,
74 FINDER_CLASS_NAME_LIST, "findByGroupId",
75 new String[] {
76 Long.class.getName(),
77
78 "java.lang.Integer", "java.lang.Integer",
79 "com.liferay.portal.kernel.util.OrderByComparator"
80 });
81 public static final FinderPath FINDER_PATH_COUNT_BY_GROUPID = new FinderPath(BlogsStatsUserModelImpl.ENTITY_CACHE_ENABLED,
82 BlogsStatsUserModelImpl.FINDER_CACHE_ENABLED,
83 FINDER_CLASS_NAME_LIST, "countByGroupId",
84 new String[] { Long.class.getName() });
85 public static final FinderPath FINDER_PATH_FIND_BY_USERID = new FinderPath(BlogsStatsUserModelImpl.ENTITY_CACHE_ENABLED,
86 BlogsStatsUserModelImpl.FINDER_CACHE_ENABLED,
87 FINDER_CLASS_NAME_LIST, "findByUserId",
88 new String[] {
89 Long.class.getName(),
90
91 "java.lang.Integer", "java.lang.Integer",
92 "com.liferay.portal.kernel.util.OrderByComparator"
93 });
94 public static final FinderPath FINDER_PATH_COUNT_BY_USERID = new FinderPath(BlogsStatsUserModelImpl.ENTITY_CACHE_ENABLED,
95 BlogsStatsUserModelImpl.FINDER_CACHE_ENABLED,
96 FINDER_CLASS_NAME_LIST, "countByUserId",
97 new String[] { Long.class.getName() });
98 public static final FinderPath FINDER_PATH_FETCH_BY_G_U = new FinderPath(BlogsStatsUserModelImpl.ENTITY_CACHE_ENABLED,
99 BlogsStatsUserModelImpl.FINDER_CACHE_ENABLED,
100 FINDER_CLASS_NAME_ENTITY, "fetchByG_U",
101 new String[] { Long.class.getName(), Long.class.getName() });
102 public static final FinderPath FINDER_PATH_COUNT_BY_G_U = new FinderPath(BlogsStatsUserModelImpl.ENTITY_CACHE_ENABLED,
103 BlogsStatsUserModelImpl.FINDER_CACHE_ENABLED,
104 FINDER_CLASS_NAME_LIST, "countByG_U",
105 new String[] { Long.class.getName(), Long.class.getName() });
106 public static final FinderPath FINDER_PATH_FIND_BY_G_E = new FinderPath(BlogsStatsUserModelImpl.ENTITY_CACHE_ENABLED,
107 BlogsStatsUserModelImpl.FINDER_CACHE_ENABLED,
108 FINDER_CLASS_NAME_LIST, "findByG_E",
109 new String[] {
110 Long.class.getName(), Integer.class.getName(),
111
112 "java.lang.Integer", "java.lang.Integer",
113 "com.liferay.portal.kernel.util.OrderByComparator"
114 });
115 public static final FinderPath FINDER_PATH_COUNT_BY_G_E = new FinderPath(BlogsStatsUserModelImpl.ENTITY_CACHE_ENABLED,
116 BlogsStatsUserModelImpl.FINDER_CACHE_ENABLED,
117 FINDER_CLASS_NAME_LIST, "countByG_E",
118 new String[] { Long.class.getName(), Integer.class.getName() });
119 public static final FinderPath FINDER_PATH_FIND_BY_C_E = new FinderPath(BlogsStatsUserModelImpl.ENTITY_CACHE_ENABLED,
120 BlogsStatsUserModelImpl.FINDER_CACHE_ENABLED,
121 FINDER_CLASS_NAME_LIST, "findByC_E",
122 new String[] {
123 Long.class.getName(), Integer.class.getName(),
124
125 "java.lang.Integer", "java.lang.Integer",
126 "com.liferay.portal.kernel.util.OrderByComparator"
127 });
128 public static final FinderPath FINDER_PATH_COUNT_BY_C_E = new FinderPath(BlogsStatsUserModelImpl.ENTITY_CACHE_ENABLED,
129 BlogsStatsUserModelImpl.FINDER_CACHE_ENABLED,
130 FINDER_CLASS_NAME_LIST, "countByC_E",
131 new String[] { Long.class.getName(), Integer.class.getName() });
132 public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(BlogsStatsUserModelImpl.ENTITY_CACHE_ENABLED,
133 BlogsStatsUserModelImpl.FINDER_CACHE_ENABLED,
134 FINDER_CLASS_NAME_LIST, "findAll", new String[0]);
135 public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(BlogsStatsUserModelImpl.ENTITY_CACHE_ENABLED,
136 BlogsStatsUserModelImpl.FINDER_CACHE_ENABLED,
137 FINDER_CLASS_NAME_LIST, "countAll", new String[0]);
138
139 public void cacheResult(BlogsStatsUser blogsStatsUser) {
140 EntityCacheUtil.putResult(BlogsStatsUserModelImpl.ENTITY_CACHE_ENABLED,
141 BlogsStatsUserImpl.class, blogsStatsUser.getPrimaryKey(),
142 blogsStatsUser);
143
144 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_U,
145 new Object[] {
146 new Long(blogsStatsUser.getGroupId()),
147 new Long(blogsStatsUser.getUserId())
148 }, blogsStatsUser);
149 }
150
151 public void cacheResult(List<BlogsStatsUser> blogsStatsUsers) {
152 for (BlogsStatsUser blogsStatsUser : blogsStatsUsers) {
153 if (EntityCacheUtil.getResult(
154 BlogsStatsUserModelImpl.ENTITY_CACHE_ENABLED,
155 BlogsStatsUserImpl.class,
156 blogsStatsUser.getPrimaryKey(), this) == null) {
157 cacheResult(blogsStatsUser);
158 }
159 }
160 }
161
162 public void clearCache() {
163 CacheRegistry.clear(BlogsStatsUserImpl.class.getName());
164 EntityCacheUtil.clearCache(BlogsStatsUserImpl.class.getName());
165 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
166 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
167 }
168
169 public void clearCache(BlogsStatsUser blogsStatsUser) {
170 EntityCacheUtil.removeResult(BlogsStatsUserModelImpl.ENTITY_CACHE_ENABLED,
171 BlogsStatsUserImpl.class, blogsStatsUser.getPrimaryKey());
172
173 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_U,
174 new Object[] {
175 new Long(blogsStatsUser.getGroupId()),
176 new Long(blogsStatsUser.getUserId())
177 });
178 }
179
180 public BlogsStatsUser create(long statsUserId) {
181 BlogsStatsUser blogsStatsUser = new BlogsStatsUserImpl();
182
183 blogsStatsUser.setNew(true);
184 blogsStatsUser.setPrimaryKey(statsUserId);
185
186 return blogsStatsUser;
187 }
188
189 public BlogsStatsUser remove(Serializable primaryKey)
190 throws NoSuchModelException, SystemException {
191 return remove(((Long)primaryKey).longValue());
192 }
193
194 public BlogsStatsUser remove(long statsUserId)
195 throws NoSuchStatsUserException, SystemException {
196 Session session = null;
197
198 try {
199 session = openSession();
200
201 BlogsStatsUser blogsStatsUser = (BlogsStatsUser)session.get(BlogsStatsUserImpl.class,
202 new Long(statsUserId));
203
204 if (blogsStatsUser == null) {
205 if (_log.isWarnEnabled()) {
206 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + statsUserId);
207 }
208
209 throw new NoSuchStatsUserException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
210 statsUserId);
211 }
212
213 return remove(blogsStatsUser);
214 }
215 catch (NoSuchStatsUserException nsee) {
216 throw nsee;
217 }
218 catch (Exception e) {
219 throw processException(e);
220 }
221 finally {
222 closeSession(session);
223 }
224 }
225
226 public BlogsStatsUser remove(BlogsStatsUser blogsStatsUser)
227 throws SystemException {
228 for (ModelListener<BlogsStatsUser> listener : listeners) {
229 listener.onBeforeRemove(blogsStatsUser);
230 }
231
232 blogsStatsUser = removeImpl(blogsStatsUser);
233
234 for (ModelListener<BlogsStatsUser> listener : listeners) {
235 listener.onAfterRemove(blogsStatsUser);
236 }
237
238 return blogsStatsUser;
239 }
240
241 protected BlogsStatsUser removeImpl(BlogsStatsUser blogsStatsUser)
242 throws SystemException {
243 blogsStatsUser = toUnwrappedModel(blogsStatsUser);
244
245 Session session = null;
246
247 try {
248 session = openSession();
249
250 if (blogsStatsUser.isCachedModel() || BatchSessionUtil.isEnabled()) {
251 Object staleObject = session.get(BlogsStatsUserImpl.class,
252 blogsStatsUser.getPrimaryKeyObj());
253
254 if (staleObject != null) {
255 session.evict(staleObject);
256 }
257 }
258
259 session.delete(blogsStatsUser);
260
261 session.flush();
262 }
263 catch (Exception e) {
264 throw processException(e);
265 }
266 finally {
267 closeSession(session);
268 }
269
270 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
271
272 BlogsStatsUserModelImpl blogsStatsUserModelImpl = (BlogsStatsUserModelImpl)blogsStatsUser;
273
274 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_U,
275 new Object[] {
276 new Long(blogsStatsUserModelImpl.getOriginalGroupId()),
277 new Long(blogsStatsUserModelImpl.getOriginalUserId())
278 });
279
280 EntityCacheUtil.removeResult(BlogsStatsUserModelImpl.ENTITY_CACHE_ENABLED,
281 BlogsStatsUserImpl.class, blogsStatsUser.getPrimaryKey());
282
283 return blogsStatsUser;
284 }
285
286 public BlogsStatsUser updateImpl(
287 com.liferay.portlet.blogs.model.BlogsStatsUser blogsStatsUser,
288 boolean merge) throws SystemException {
289 blogsStatsUser = toUnwrappedModel(blogsStatsUser);
290
291 boolean isNew = blogsStatsUser.isNew();
292
293 BlogsStatsUserModelImpl blogsStatsUserModelImpl = (BlogsStatsUserModelImpl)blogsStatsUser;
294
295 Session session = null;
296
297 try {
298 session = openSession();
299
300 BatchSessionUtil.update(session, blogsStatsUser, merge);
301
302 blogsStatsUser.setNew(false);
303 }
304 catch (Exception e) {
305 throw processException(e);
306 }
307 finally {
308 closeSession(session);
309 }
310
311 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
312
313 EntityCacheUtil.putResult(BlogsStatsUserModelImpl.ENTITY_CACHE_ENABLED,
314 BlogsStatsUserImpl.class, blogsStatsUser.getPrimaryKey(),
315 blogsStatsUser);
316
317 if (!isNew &&
318 ((blogsStatsUser.getGroupId() != blogsStatsUserModelImpl.getOriginalGroupId()) ||
319 (blogsStatsUser.getUserId() != blogsStatsUserModelImpl.getOriginalUserId()))) {
320 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_U,
321 new Object[] {
322 new Long(blogsStatsUserModelImpl.getOriginalGroupId()),
323 new Long(blogsStatsUserModelImpl.getOriginalUserId())
324 });
325 }
326
327 if (isNew ||
328 ((blogsStatsUser.getGroupId() != blogsStatsUserModelImpl.getOriginalGroupId()) ||
329 (blogsStatsUser.getUserId() != blogsStatsUserModelImpl.getOriginalUserId()))) {
330 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_U,
331 new Object[] {
332 new Long(blogsStatsUser.getGroupId()),
333 new Long(blogsStatsUser.getUserId())
334 }, blogsStatsUser);
335 }
336
337 return blogsStatsUser;
338 }
339
340 protected BlogsStatsUser toUnwrappedModel(BlogsStatsUser blogsStatsUser) {
341 if (blogsStatsUser instanceof BlogsStatsUserImpl) {
342 return blogsStatsUser;
343 }
344
345 BlogsStatsUserImpl blogsStatsUserImpl = new BlogsStatsUserImpl();
346
347 blogsStatsUserImpl.setNew(blogsStatsUser.isNew());
348 blogsStatsUserImpl.setPrimaryKey(blogsStatsUser.getPrimaryKey());
349
350 blogsStatsUserImpl.setStatsUserId(blogsStatsUser.getStatsUserId());
351 blogsStatsUserImpl.setGroupId(blogsStatsUser.getGroupId());
352 blogsStatsUserImpl.setCompanyId(blogsStatsUser.getCompanyId());
353 blogsStatsUserImpl.setUserId(blogsStatsUser.getUserId());
354 blogsStatsUserImpl.setEntryCount(blogsStatsUser.getEntryCount());
355 blogsStatsUserImpl.setLastPostDate(blogsStatsUser.getLastPostDate());
356 blogsStatsUserImpl.setRatingsTotalEntries(blogsStatsUser.getRatingsTotalEntries());
357 blogsStatsUserImpl.setRatingsTotalScore(blogsStatsUser.getRatingsTotalScore());
358 blogsStatsUserImpl.setRatingsAverageScore(blogsStatsUser.getRatingsAverageScore());
359
360 return blogsStatsUserImpl;
361 }
362
363 public BlogsStatsUser findByPrimaryKey(Serializable primaryKey)
364 throws NoSuchModelException, SystemException {
365 return findByPrimaryKey(((Long)primaryKey).longValue());
366 }
367
368 public BlogsStatsUser findByPrimaryKey(long statsUserId)
369 throws NoSuchStatsUserException, SystemException {
370 BlogsStatsUser blogsStatsUser = fetchByPrimaryKey(statsUserId);
371
372 if (blogsStatsUser == null) {
373 if (_log.isWarnEnabled()) {
374 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + statsUserId);
375 }
376
377 throw new NoSuchStatsUserException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
378 statsUserId);
379 }
380
381 return blogsStatsUser;
382 }
383
384 public BlogsStatsUser fetchByPrimaryKey(Serializable primaryKey)
385 throws SystemException {
386 return fetchByPrimaryKey(((Long)primaryKey).longValue());
387 }
388
389 public BlogsStatsUser fetchByPrimaryKey(long statsUserId)
390 throws SystemException {
391 BlogsStatsUser blogsStatsUser = (BlogsStatsUser)EntityCacheUtil.getResult(BlogsStatsUserModelImpl.ENTITY_CACHE_ENABLED,
392 BlogsStatsUserImpl.class, statsUserId, this);
393
394 if (blogsStatsUser == null) {
395 Session session = null;
396
397 try {
398 session = openSession();
399
400 blogsStatsUser = (BlogsStatsUser)session.get(BlogsStatsUserImpl.class,
401 new Long(statsUserId));
402 }
403 catch (Exception e) {
404 throw processException(e);
405 }
406 finally {
407 if (blogsStatsUser != null) {
408 cacheResult(blogsStatsUser);
409 }
410
411 closeSession(session);
412 }
413 }
414
415 return blogsStatsUser;
416 }
417
418 public List<BlogsStatsUser> findByGroupId(long groupId)
419 throws SystemException {
420 return findByGroupId(groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
421 }
422
423 public List<BlogsStatsUser> findByGroupId(long groupId, int start, int end)
424 throws SystemException {
425 return findByGroupId(groupId, start, end, null);
426 }
427
428 public List<BlogsStatsUser> findByGroupId(long groupId, int start, int end,
429 OrderByComparator orderByComparator) throws SystemException {
430 Object[] finderArgs = new Object[] {
431 new Long(groupId),
432
433 String.valueOf(start), String.valueOf(end),
434 String.valueOf(orderByComparator)
435 };
436
437 List<BlogsStatsUser> list = (List<BlogsStatsUser>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_GROUPID,
438 finderArgs, this);
439
440 if (list == null) {
441 Session session = null;
442
443 try {
444 session = openSession();
445
446 StringBundler query = null;
447
448 if (orderByComparator != null) {
449 query = new StringBundler(3 +
450 (orderByComparator.getOrderByFields().length * 3));
451 }
452 else {
453 query = new StringBundler(3);
454 }
455
456 query.append(_SQL_SELECT_BLOGSSTATSUSER_WHERE);
457
458 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
459
460 if (orderByComparator != null) {
461 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
462 orderByComparator);
463 }
464
465 else {
466 query.append(BlogsStatsUserModelImpl.ORDER_BY_JPQL);
467 }
468
469 String sql = query.toString();
470
471 Query q = session.createQuery(sql);
472
473 QueryPos qPos = QueryPos.getInstance(q);
474
475 qPos.add(groupId);
476
477 list = (List<BlogsStatsUser>)QueryUtil.list(q, getDialect(),
478 start, end);
479 }
480 catch (Exception e) {
481 throw processException(e);
482 }
483 finally {
484 if (list == null) {
485 list = new ArrayList<BlogsStatsUser>();
486 }
487
488 cacheResult(list);
489
490 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_GROUPID,
491 finderArgs, list);
492
493 closeSession(session);
494 }
495 }
496
497 return list;
498 }
499
500 public BlogsStatsUser findByGroupId_First(long groupId,
501 OrderByComparator orderByComparator)
502 throws NoSuchStatsUserException, SystemException {
503 List<BlogsStatsUser> list = findByGroupId(groupId, 0, 1,
504 orderByComparator);
505
506 if (list.isEmpty()) {
507 StringBundler msg = new StringBundler(4);
508
509 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
510
511 msg.append("groupId=");
512 msg.append(groupId);
513
514 msg.append(StringPool.CLOSE_CURLY_BRACE);
515
516 throw new NoSuchStatsUserException(msg.toString());
517 }
518 else {
519 return list.get(0);
520 }
521 }
522
523 public BlogsStatsUser findByGroupId_Last(long groupId,
524 OrderByComparator orderByComparator)
525 throws NoSuchStatsUserException, SystemException {
526 int count = countByGroupId(groupId);
527
528 List<BlogsStatsUser> list = findByGroupId(groupId, count - 1, count,
529 orderByComparator);
530
531 if (list.isEmpty()) {
532 StringBundler msg = new StringBundler(4);
533
534 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
535
536 msg.append("groupId=");
537 msg.append(groupId);
538
539 msg.append(StringPool.CLOSE_CURLY_BRACE);
540
541 throw new NoSuchStatsUserException(msg.toString());
542 }
543 else {
544 return list.get(0);
545 }
546 }
547
548 public BlogsStatsUser[] findByGroupId_PrevAndNext(long statsUserId,
549 long groupId, OrderByComparator orderByComparator)
550 throws NoSuchStatsUserException, SystemException {
551 BlogsStatsUser blogsStatsUser = findByPrimaryKey(statsUserId);
552
553 Session session = null;
554
555 try {
556 session = openSession();
557
558 BlogsStatsUser[] array = new BlogsStatsUserImpl[3];
559
560 array[0] = getByGroupId_PrevAndNext(session, blogsStatsUser,
561 groupId, orderByComparator, true);
562
563 array[1] = blogsStatsUser;
564
565 array[2] = getByGroupId_PrevAndNext(session, blogsStatsUser,
566 groupId, orderByComparator, false);
567
568 return array;
569 }
570 catch (Exception e) {
571 throw processException(e);
572 }
573 finally {
574 closeSession(session);
575 }
576 }
577
578 protected BlogsStatsUser getByGroupId_PrevAndNext(Session session,
579 BlogsStatsUser blogsStatsUser, long groupId,
580 OrderByComparator orderByComparator, boolean previous) {
581 StringBundler query = null;
582
583 if (orderByComparator != null) {
584 query = new StringBundler(6 +
585 (orderByComparator.getOrderByFields().length * 6));
586 }
587 else {
588 query = new StringBundler(3);
589 }
590
591 query.append(_SQL_SELECT_BLOGSSTATSUSER_WHERE);
592
593 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
594
595 if (orderByComparator != null) {
596 String[] orderByFields = orderByComparator.getOrderByFields();
597
598 if (orderByFields.length > 0) {
599 query.append(WHERE_AND);
600 }
601
602 for (int i = 0; i < orderByFields.length; i++) {
603 query.append(_ORDER_BY_ENTITY_ALIAS);
604 query.append(orderByFields[i]);
605
606 if ((i + 1) < orderByFields.length) {
607 if (orderByComparator.isAscending() ^ previous) {
608 query.append(WHERE_GREATER_THAN_HAS_NEXT);
609 }
610 else {
611 query.append(WHERE_LESSER_THAN_HAS_NEXT);
612 }
613 }
614 else {
615 if (orderByComparator.isAscending() ^ previous) {
616 query.append(WHERE_GREATER_THAN);
617 }
618 else {
619 query.append(WHERE_LESSER_THAN);
620 }
621 }
622 }
623
624 query.append(ORDER_BY_CLAUSE);
625
626 for (int i = 0; i < orderByFields.length; i++) {
627 query.append(_ORDER_BY_ENTITY_ALIAS);
628 query.append(orderByFields[i]);
629
630 if ((i + 1) < orderByFields.length) {
631 if (orderByComparator.isAscending() ^ previous) {
632 query.append(ORDER_BY_ASC_HAS_NEXT);
633 }
634 else {
635 query.append(ORDER_BY_DESC_HAS_NEXT);
636 }
637 }
638 else {
639 if (orderByComparator.isAscending() ^ previous) {
640 query.append(ORDER_BY_ASC);
641 }
642 else {
643 query.append(ORDER_BY_DESC);
644 }
645 }
646 }
647 }
648
649 else {
650 query.append(BlogsStatsUserModelImpl.ORDER_BY_JPQL);
651 }
652
653 String sql = query.toString();
654
655 Query q = session.createQuery(sql);
656
657 q.setFirstResult(0);
658 q.setMaxResults(2);
659
660 QueryPos qPos = QueryPos.getInstance(q);
661
662 qPos.add(groupId);
663
664 if (orderByComparator != null) {
665 Object[] values = orderByComparator.getOrderByValues(blogsStatsUser);
666
667 for (Object value : values) {
668 qPos.add(value);
669 }
670 }
671
672 List<BlogsStatsUser> list = q.list();
673
674 if (list.size() == 2) {
675 return list.get(1);
676 }
677 else {
678 return null;
679 }
680 }
681
682 public List<BlogsStatsUser> findByUserId(long userId)
683 throws SystemException {
684 return findByUserId(userId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
685 }
686
687 public List<BlogsStatsUser> findByUserId(long userId, int start, int end)
688 throws SystemException {
689 return findByUserId(userId, start, end, null);
690 }
691
692 public List<BlogsStatsUser> findByUserId(long userId, int start, int end,
693 OrderByComparator orderByComparator) throws SystemException {
694 Object[] finderArgs = new Object[] {
695 new Long(userId),
696
697 String.valueOf(start), String.valueOf(end),
698 String.valueOf(orderByComparator)
699 };
700
701 List<BlogsStatsUser> list = (List<BlogsStatsUser>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_USERID,
702 finderArgs, this);
703
704 if (list == null) {
705 Session session = null;
706
707 try {
708 session = openSession();
709
710 StringBundler query = null;
711
712 if (orderByComparator != null) {
713 query = new StringBundler(3 +
714 (orderByComparator.getOrderByFields().length * 3));
715 }
716 else {
717 query = new StringBundler(3);
718 }
719
720 query.append(_SQL_SELECT_BLOGSSTATSUSER_WHERE);
721
722 query.append(_FINDER_COLUMN_USERID_USERID_2);
723
724 if (orderByComparator != null) {
725 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
726 orderByComparator);
727 }
728
729 else {
730 query.append(BlogsStatsUserModelImpl.ORDER_BY_JPQL);
731 }
732
733 String sql = query.toString();
734
735 Query q = session.createQuery(sql);
736
737 QueryPos qPos = QueryPos.getInstance(q);
738
739 qPos.add(userId);
740
741 list = (List<BlogsStatsUser>)QueryUtil.list(q, getDialect(),
742 start, end);
743 }
744 catch (Exception e) {
745 throw processException(e);
746 }
747 finally {
748 if (list == null) {
749 list = new ArrayList<BlogsStatsUser>();
750 }
751
752 cacheResult(list);
753
754 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_USERID,
755 finderArgs, list);
756
757 closeSession(session);
758 }
759 }
760
761 return list;
762 }
763
764 public BlogsStatsUser findByUserId_First(long userId,
765 OrderByComparator orderByComparator)
766 throws NoSuchStatsUserException, SystemException {
767 List<BlogsStatsUser> list = findByUserId(userId, 0, 1, orderByComparator);
768
769 if (list.isEmpty()) {
770 StringBundler msg = new StringBundler(4);
771
772 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
773
774 msg.append("userId=");
775 msg.append(userId);
776
777 msg.append(StringPool.CLOSE_CURLY_BRACE);
778
779 throw new NoSuchStatsUserException(msg.toString());
780 }
781 else {
782 return list.get(0);
783 }
784 }
785
786 public BlogsStatsUser findByUserId_Last(long userId,
787 OrderByComparator orderByComparator)
788 throws NoSuchStatsUserException, SystemException {
789 int count = countByUserId(userId);
790
791 List<BlogsStatsUser> list = findByUserId(userId, count - 1, count,
792 orderByComparator);
793
794 if (list.isEmpty()) {
795 StringBundler msg = new StringBundler(4);
796
797 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
798
799 msg.append("userId=");
800 msg.append(userId);
801
802 msg.append(StringPool.CLOSE_CURLY_BRACE);
803
804 throw new NoSuchStatsUserException(msg.toString());
805 }
806 else {
807 return list.get(0);
808 }
809 }
810
811 public BlogsStatsUser[] findByUserId_PrevAndNext(long statsUserId,
812 long userId, OrderByComparator orderByComparator)
813 throws NoSuchStatsUserException, SystemException {
814 BlogsStatsUser blogsStatsUser = findByPrimaryKey(statsUserId);
815
816 Session session = null;
817
818 try {
819 session = openSession();
820
821 BlogsStatsUser[] array = new BlogsStatsUserImpl[3];
822
823 array[0] = getByUserId_PrevAndNext(session, blogsStatsUser, userId,
824 orderByComparator, true);
825
826 array[1] = blogsStatsUser;
827
828 array[2] = getByUserId_PrevAndNext(session, blogsStatsUser, userId,
829 orderByComparator, false);
830
831 return array;
832 }
833 catch (Exception e) {
834 throw processException(e);
835 }
836 finally {
837 closeSession(session);
838 }
839 }
840
841 protected BlogsStatsUser getByUserId_PrevAndNext(Session session,
842 BlogsStatsUser blogsStatsUser, long userId,
843 OrderByComparator orderByComparator, boolean previous) {
844 StringBundler query = null;
845
846 if (orderByComparator != null) {
847 query = new StringBundler(6 +
848 (orderByComparator.getOrderByFields().length * 6));
849 }
850 else {
851 query = new StringBundler(3);
852 }
853
854 query.append(_SQL_SELECT_BLOGSSTATSUSER_WHERE);
855
856 query.append(_FINDER_COLUMN_USERID_USERID_2);
857
858 if (orderByComparator != null) {
859 String[] orderByFields = orderByComparator.getOrderByFields();
860
861 if (orderByFields.length > 0) {
862 query.append(WHERE_AND);
863 }
864
865 for (int i = 0; i < orderByFields.length; i++) {
866 query.append(_ORDER_BY_ENTITY_ALIAS);
867 query.append(orderByFields[i]);
868
869 if ((i + 1) < orderByFields.length) {
870 if (orderByComparator.isAscending() ^ previous) {
871 query.append(WHERE_GREATER_THAN_HAS_NEXT);
872 }
873 else {
874 query.append(WHERE_LESSER_THAN_HAS_NEXT);
875 }
876 }
877 else {
878 if (orderByComparator.isAscending() ^ previous) {
879 query.append(WHERE_GREATER_THAN);
880 }
881 else {
882 query.append(WHERE_LESSER_THAN);
883 }
884 }
885 }
886
887 query.append(ORDER_BY_CLAUSE);
888
889 for (int i = 0; i < orderByFields.length; i++) {
890 query.append(_ORDER_BY_ENTITY_ALIAS);
891 query.append(orderByFields[i]);
892
893 if ((i + 1) < orderByFields.length) {
894 if (orderByComparator.isAscending() ^ previous) {
895 query.append(ORDER_BY_ASC_HAS_NEXT);
896 }
897 else {
898 query.append(ORDER_BY_DESC_HAS_NEXT);
899 }
900 }
901 else {
902 if (orderByComparator.isAscending() ^ previous) {
903 query.append(ORDER_BY_ASC);
904 }
905 else {
906 query.append(ORDER_BY_DESC);
907 }
908 }
909 }
910 }
911
912 else {
913 query.append(BlogsStatsUserModelImpl.ORDER_BY_JPQL);
914 }
915
916 String sql = query.toString();
917
918 Query q = session.createQuery(sql);
919
920 q.setFirstResult(0);
921 q.setMaxResults(2);
922
923 QueryPos qPos = QueryPos.getInstance(q);
924
925 qPos.add(userId);
926
927 if (orderByComparator != null) {
928 Object[] values = orderByComparator.getOrderByValues(blogsStatsUser);
929
930 for (Object value : values) {
931 qPos.add(value);
932 }
933 }
934
935 List<BlogsStatsUser> list = q.list();
936
937 if (list.size() == 2) {
938 return list.get(1);
939 }
940 else {
941 return null;
942 }
943 }
944
945 public BlogsStatsUser findByG_U(long groupId, long userId)
946 throws NoSuchStatsUserException, SystemException {
947 BlogsStatsUser blogsStatsUser = fetchByG_U(groupId, userId);
948
949 if (blogsStatsUser == null) {
950 StringBundler msg = new StringBundler(6);
951
952 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
953
954 msg.append("groupId=");
955 msg.append(groupId);
956
957 msg.append(", userId=");
958 msg.append(userId);
959
960 msg.append(StringPool.CLOSE_CURLY_BRACE);
961
962 if (_log.isWarnEnabled()) {
963 _log.warn(msg.toString());
964 }
965
966 throw new NoSuchStatsUserException(msg.toString());
967 }
968
969 return blogsStatsUser;
970 }
971
972 public BlogsStatsUser fetchByG_U(long groupId, long userId)
973 throws SystemException {
974 return fetchByG_U(groupId, userId, true);
975 }
976
977 public BlogsStatsUser fetchByG_U(long groupId, long userId,
978 boolean retrieveFromCache) throws SystemException {
979 Object[] finderArgs = new Object[] { new Long(groupId), new Long(userId) };
980
981 Object result = null;
982
983 if (retrieveFromCache) {
984 result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_G_U,
985 finderArgs, this);
986 }
987
988 if (result == null) {
989 Session session = null;
990
991 try {
992 session = openSession();
993
994 StringBundler query = new StringBundler(4);
995
996 query.append(_SQL_SELECT_BLOGSSTATSUSER_WHERE);
997
998 query.append(_FINDER_COLUMN_G_U_GROUPID_2);
999
1000 query.append(_FINDER_COLUMN_G_U_USERID_2);
1001
1002 query.append(BlogsStatsUserModelImpl.ORDER_BY_JPQL);
1003
1004 String sql = query.toString();
1005
1006 Query q = session.createQuery(sql);
1007
1008 QueryPos qPos = QueryPos.getInstance(q);
1009
1010 qPos.add(groupId);
1011
1012 qPos.add(userId);
1013
1014 List<BlogsStatsUser> list = q.list();
1015
1016 result = list;
1017
1018 BlogsStatsUser blogsStatsUser = null;
1019
1020 if (list.isEmpty()) {
1021 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_U,
1022 finderArgs, list);
1023 }
1024 else {
1025 blogsStatsUser = list.get(0);
1026
1027 cacheResult(blogsStatsUser);
1028
1029 if ((blogsStatsUser.getGroupId() != groupId) ||
1030 (blogsStatsUser.getUserId() != userId)) {
1031 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_U,
1032 finderArgs, blogsStatsUser);
1033 }
1034 }
1035
1036 return blogsStatsUser;
1037 }
1038 catch (Exception e) {
1039 throw processException(e);
1040 }
1041 finally {
1042 if (result == null) {
1043 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_U,
1044 finderArgs, new ArrayList<BlogsStatsUser>());
1045 }
1046
1047 closeSession(session);
1048 }
1049 }
1050 else {
1051 if (result instanceof List<?>) {
1052 return null;
1053 }
1054 else {
1055 return (BlogsStatsUser)result;
1056 }
1057 }
1058 }
1059
1060 public List<BlogsStatsUser> findByG_E(long groupId, int entryCount)
1061 throws SystemException {
1062 return findByG_E(groupId, entryCount, QueryUtil.ALL_POS,
1063 QueryUtil.ALL_POS, null);
1064 }
1065
1066 public List<BlogsStatsUser> findByG_E(long groupId, int entryCount,
1067 int start, int end) throws SystemException {
1068 return findByG_E(groupId, entryCount, start, end, null);
1069 }
1070
1071 public List<BlogsStatsUser> findByG_E(long groupId, int entryCount,
1072 int start, int end, OrderByComparator orderByComparator)
1073 throws SystemException {
1074 Object[] finderArgs = new Object[] {
1075 new Long(groupId), new Integer(entryCount),
1076
1077 String.valueOf(start), String.valueOf(end),
1078 String.valueOf(orderByComparator)
1079 };
1080
1081 List<BlogsStatsUser> list = (List<BlogsStatsUser>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_E,
1082 finderArgs, this);
1083
1084 if (list == null) {
1085 Session session = null;
1086
1087 try {
1088 session = openSession();
1089
1090 StringBundler query = null;
1091
1092 if (orderByComparator != null) {
1093 query = new StringBundler(4 +
1094 (orderByComparator.getOrderByFields().length * 3));
1095 }
1096 else {
1097 query = new StringBundler(4);
1098 }
1099
1100 query.append(_SQL_SELECT_BLOGSSTATSUSER_WHERE);
1101
1102 query.append(_FINDER_COLUMN_G_E_GROUPID_2);
1103
1104 query.append(_FINDER_COLUMN_G_E_ENTRYCOUNT_2);
1105
1106 if (orderByComparator != null) {
1107 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1108 orderByComparator);
1109 }
1110
1111 else {
1112 query.append(BlogsStatsUserModelImpl.ORDER_BY_JPQL);
1113 }
1114
1115 String sql = query.toString();
1116
1117 Query q = session.createQuery(sql);
1118
1119 QueryPos qPos = QueryPos.getInstance(q);
1120
1121 qPos.add(groupId);
1122
1123 qPos.add(entryCount);
1124
1125 list = (List<BlogsStatsUser>)QueryUtil.list(q, getDialect(),
1126 start, end);
1127 }
1128 catch (Exception e) {
1129 throw processException(e);
1130 }
1131 finally {
1132 if (list == null) {
1133 list = new ArrayList<BlogsStatsUser>();
1134 }
1135
1136 cacheResult(list);
1137
1138 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_E, finderArgs,
1139 list);
1140
1141 closeSession(session);
1142 }
1143 }
1144
1145 return list;
1146 }
1147
1148 public BlogsStatsUser findByG_E_First(long groupId, int entryCount,
1149 OrderByComparator orderByComparator)
1150 throws NoSuchStatsUserException, SystemException {
1151 List<BlogsStatsUser> list = findByG_E(groupId, entryCount, 0, 1,
1152 orderByComparator);
1153
1154 if (list.isEmpty()) {
1155 StringBundler msg = new StringBundler(6);
1156
1157 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1158
1159 msg.append("groupId=");
1160 msg.append(groupId);
1161
1162 msg.append(", entryCount=");
1163 msg.append(entryCount);
1164
1165 msg.append(StringPool.CLOSE_CURLY_BRACE);
1166
1167 throw new NoSuchStatsUserException(msg.toString());
1168 }
1169 else {
1170 return list.get(0);
1171 }
1172 }
1173
1174 public BlogsStatsUser findByG_E_Last(long groupId, int entryCount,
1175 OrderByComparator orderByComparator)
1176 throws NoSuchStatsUserException, SystemException {
1177 int count = countByG_E(groupId, entryCount);
1178
1179 List<BlogsStatsUser> list = findByG_E(groupId, entryCount, count - 1,
1180 count, orderByComparator);
1181
1182 if (list.isEmpty()) {
1183 StringBundler msg = new StringBundler(6);
1184
1185 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1186
1187 msg.append("groupId=");
1188 msg.append(groupId);
1189
1190 msg.append(", entryCount=");
1191 msg.append(entryCount);
1192
1193 msg.append(StringPool.CLOSE_CURLY_BRACE);
1194
1195 throw new NoSuchStatsUserException(msg.toString());
1196 }
1197 else {
1198 return list.get(0);
1199 }
1200 }
1201
1202 public BlogsStatsUser[] findByG_E_PrevAndNext(long statsUserId,
1203 long groupId, int entryCount, OrderByComparator orderByComparator)
1204 throws NoSuchStatsUserException, SystemException {
1205 BlogsStatsUser blogsStatsUser = findByPrimaryKey(statsUserId);
1206
1207 Session session = null;
1208
1209 try {
1210 session = openSession();
1211
1212 BlogsStatsUser[] array = new BlogsStatsUserImpl[3];
1213
1214 array[0] = getByG_E_PrevAndNext(session, blogsStatsUser, groupId,
1215 entryCount, orderByComparator, true);
1216
1217 array[1] = blogsStatsUser;
1218
1219 array[2] = getByG_E_PrevAndNext(session, blogsStatsUser, groupId,
1220 entryCount, orderByComparator, false);
1221
1222 return array;
1223 }
1224 catch (Exception e) {
1225 throw processException(e);
1226 }
1227 finally {
1228 closeSession(session);
1229 }
1230 }
1231
1232 protected BlogsStatsUser getByG_E_PrevAndNext(Session session,
1233 BlogsStatsUser blogsStatsUser, long groupId, int entryCount,
1234 OrderByComparator orderByComparator, boolean previous) {
1235 StringBundler query = null;
1236
1237 if (orderByComparator != null) {
1238 query = new StringBundler(6 +
1239 (orderByComparator.getOrderByFields().length * 6));
1240 }
1241 else {
1242 query = new StringBundler(3);
1243 }
1244
1245 query.append(_SQL_SELECT_BLOGSSTATSUSER_WHERE);
1246
1247 query.append(_FINDER_COLUMN_G_E_GROUPID_2);
1248
1249 query.append(_FINDER_COLUMN_G_E_ENTRYCOUNT_2);
1250
1251 if (orderByComparator != null) {
1252 String[] orderByFields = orderByComparator.getOrderByFields();
1253
1254 if (orderByFields.length > 0) {
1255 query.append(WHERE_AND);
1256 }
1257
1258 for (int i = 0; i < orderByFields.length; i++) {
1259 query.append(_ORDER_BY_ENTITY_ALIAS);
1260 query.append(orderByFields[i]);
1261
1262 if ((i + 1) < orderByFields.length) {
1263 if (orderByComparator.isAscending() ^ previous) {
1264 query.append(WHERE_GREATER_THAN_HAS_NEXT);
1265 }
1266 else {
1267 query.append(WHERE_LESSER_THAN_HAS_NEXT);
1268 }
1269 }
1270 else {
1271 if (orderByComparator.isAscending() ^ previous) {
1272 query.append(WHERE_GREATER_THAN);
1273 }
1274 else {
1275 query.append(WHERE_LESSER_THAN);
1276 }
1277 }
1278 }
1279
1280 query.append(ORDER_BY_CLAUSE);
1281
1282 for (int i = 0; i < orderByFields.length; i++) {
1283 query.append(_ORDER_BY_ENTITY_ALIAS);
1284 query.append(orderByFields[i]);
1285
1286 if ((i + 1) < orderByFields.length) {
1287 if (orderByComparator.isAscending() ^ previous) {
1288 query.append(ORDER_BY_ASC_HAS_NEXT);
1289 }
1290 else {
1291 query.append(ORDER_BY_DESC_HAS_NEXT);
1292 }
1293 }
1294 else {
1295 if (orderByComparator.isAscending() ^ previous) {
1296 query.append(ORDER_BY_ASC);
1297 }
1298 else {
1299 query.append(ORDER_BY_DESC);
1300 }
1301 }
1302 }
1303 }
1304
1305 else {
1306 query.append(BlogsStatsUserModelImpl.ORDER_BY_JPQL);
1307 }
1308
1309 String sql = query.toString();
1310
1311 Query q = session.createQuery(sql);
1312
1313 q.setFirstResult(0);
1314 q.setMaxResults(2);
1315
1316 QueryPos qPos = QueryPos.getInstance(q);
1317
1318 qPos.add(groupId);
1319
1320 qPos.add(entryCount);
1321
1322 if (orderByComparator != null) {
1323 Object[] values = orderByComparator.getOrderByValues(blogsStatsUser);
1324
1325 for (Object value : values) {
1326 qPos.add(value);
1327 }
1328 }
1329
1330 List<BlogsStatsUser> list = q.list();
1331
1332 if (list.size() == 2) {
1333 return list.get(1);
1334 }
1335 else {
1336 return null;
1337 }
1338 }
1339
1340 public List<BlogsStatsUser> findByC_E(long companyId, int entryCount)
1341 throws SystemException {
1342 return findByC_E(companyId, entryCount, QueryUtil.ALL_POS,
1343 QueryUtil.ALL_POS, null);
1344 }
1345
1346 public List<BlogsStatsUser> findByC_E(long companyId, int entryCount,
1347 int start, int end) throws SystemException {
1348 return findByC_E(companyId, entryCount, start, end, null);
1349 }
1350
1351 public List<BlogsStatsUser> findByC_E(long companyId, int entryCount,
1352 int start, int end, OrderByComparator orderByComparator)
1353 throws SystemException {
1354 Object[] finderArgs = new Object[] {
1355 new Long(companyId), new Integer(entryCount),
1356
1357 String.valueOf(start), String.valueOf(end),
1358 String.valueOf(orderByComparator)
1359 };
1360
1361 List<BlogsStatsUser> list = (List<BlogsStatsUser>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_C_E,
1362 finderArgs, this);
1363
1364 if (list == null) {
1365 Session session = null;
1366
1367 try {
1368 session = openSession();
1369
1370 StringBundler query = null;
1371
1372 if (orderByComparator != null) {
1373 query = new StringBundler(4 +
1374 (orderByComparator.getOrderByFields().length * 3));
1375 }
1376 else {
1377 query = new StringBundler(4);
1378 }
1379
1380 query.append(_SQL_SELECT_BLOGSSTATSUSER_WHERE);
1381
1382 query.append(_FINDER_COLUMN_C_E_COMPANYID_2);
1383
1384 query.append(_FINDER_COLUMN_C_E_ENTRYCOUNT_2);
1385
1386 if (orderByComparator != null) {
1387 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1388 orderByComparator);
1389 }
1390
1391 else {
1392 query.append(BlogsStatsUserModelImpl.ORDER_BY_JPQL);
1393 }
1394
1395 String sql = query.toString();
1396
1397 Query q = session.createQuery(sql);
1398
1399 QueryPos qPos = QueryPos.getInstance(q);
1400
1401 qPos.add(companyId);
1402
1403 qPos.add(entryCount);
1404
1405 list = (List<BlogsStatsUser>)QueryUtil.list(q, getDialect(),
1406 start, end);
1407 }
1408 catch (Exception e) {
1409 throw processException(e);
1410 }
1411 finally {
1412 if (list == null) {
1413 list = new ArrayList<BlogsStatsUser>();
1414 }
1415
1416 cacheResult(list);
1417
1418 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_C_E, finderArgs,
1419 list);
1420
1421 closeSession(session);
1422 }
1423 }
1424
1425 return list;
1426 }
1427
1428 public BlogsStatsUser findByC_E_First(long companyId, int entryCount,
1429 OrderByComparator orderByComparator)
1430 throws NoSuchStatsUserException, SystemException {
1431 List<BlogsStatsUser> list = findByC_E(companyId, entryCount, 0, 1,
1432 orderByComparator);
1433
1434 if (list.isEmpty()) {
1435 StringBundler msg = new StringBundler(6);
1436
1437 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1438
1439 msg.append("companyId=");
1440 msg.append(companyId);
1441
1442 msg.append(", entryCount=");
1443 msg.append(entryCount);
1444
1445 msg.append(StringPool.CLOSE_CURLY_BRACE);
1446
1447 throw new NoSuchStatsUserException(msg.toString());
1448 }
1449 else {
1450 return list.get(0);
1451 }
1452 }
1453
1454 public BlogsStatsUser findByC_E_Last(long companyId, int entryCount,
1455 OrderByComparator orderByComparator)
1456 throws NoSuchStatsUserException, SystemException {
1457 int count = countByC_E(companyId, entryCount);
1458
1459 List<BlogsStatsUser> list = findByC_E(companyId, entryCount, count - 1,
1460 count, orderByComparator);
1461
1462 if (list.isEmpty()) {
1463 StringBundler msg = new StringBundler(6);
1464
1465 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1466
1467 msg.append("companyId=");
1468 msg.append(companyId);
1469
1470 msg.append(", entryCount=");
1471 msg.append(entryCount);
1472
1473 msg.append(StringPool.CLOSE_CURLY_BRACE);
1474
1475 throw new NoSuchStatsUserException(msg.toString());
1476 }
1477 else {
1478 return list.get(0);
1479 }
1480 }
1481
1482 public BlogsStatsUser[] findByC_E_PrevAndNext(long statsUserId,
1483 long companyId, int entryCount, OrderByComparator orderByComparator)
1484 throws NoSuchStatsUserException, SystemException {
1485 BlogsStatsUser blogsStatsUser = findByPrimaryKey(statsUserId);
1486
1487 Session session = null;
1488
1489 try {
1490 session = openSession();
1491
1492 BlogsStatsUser[] array = new BlogsStatsUserImpl[3];
1493
1494 array[0] = getByC_E_PrevAndNext(session, blogsStatsUser, companyId,
1495 entryCount, orderByComparator, true);
1496
1497 array[1] = blogsStatsUser;
1498
1499 array[2] = getByC_E_PrevAndNext(session, blogsStatsUser, companyId,
1500 entryCount, orderByComparator, false);
1501
1502 return array;
1503 }
1504 catch (Exception e) {
1505 throw processException(e);
1506 }
1507 finally {
1508 closeSession(session);
1509 }
1510 }
1511
1512 protected BlogsStatsUser getByC_E_PrevAndNext(Session session,
1513 BlogsStatsUser blogsStatsUser, long companyId, int entryCount,
1514 OrderByComparator orderByComparator, boolean previous) {
1515 StringBundler query = null;
1516
1517 if (orderByComparator != null) {
1518 query = new StringBundler(6 +
1519 (orderByComparator.getOrderByFields().length * 6));
1520 }
1521 else {
1522 query = new StringBundler(3);
1523 }
1524
1525 query.append(_SQL_SELECT_BLOGSSTATSUSER_WHERE);
1526
1527 query.append(_FINDER_COLUMN_C_E_COMPANYID_2);
1528
1529 query.append(_FINDER_COLUMN_C_E_ENTRYCOUNT_2);
1530
1531 if (orderByComparator != null) {
1532 String[] orderByFields = orderByComparator.getOrderByFields();
1533
1534 if (orderByFields.length > 0) {
1535 query.append(WHERE_AND);
1536 }
1537
1538 for (int i = 0; i < orderByFields.length; i++) {
1539 query.append(_ORDER_BY_ENTITY_ALIAS);
1540 query.append(orderByFields[i]);
1541
1542 if ((i + 1) < orderByFields.length) {
1543 if (orderByComparator.isAscending() ^ previous) {
1544 query.append(WHERE_GREATER_THAN_HAS_NEXT);
1545 }
1546 else {
1547 query.append(WHERE_LESSER_THAN_HAS_NEXT);
1548 }
1549 }
1550 else {
1551 if (orderByComparator.isAscending() ^ previous) {
1552 query.append(WHERE_GREATER_THAN);
1553 }
1554 else {
1555 query.append(WHERE_LESSER_THAN);
1556 }
1557 }
1558 }
1559
1560 query.append(ORDER_BY_CLAUSE);
1561
1562 for (int i = 0; i < orderByFields.length; i++) {
1563 query.append(_ORDER_BY_ENTITY_ALIAS);
1564 query.append(orderByFields[i]);
1565
1566 if ((i + 1) < orderByFields.length) {
1567 if (orderByComparator.isAscending() ^ previous) {
1568 query.append(ORDER_BY_ASC_HAS_NEXT);
1569 }
1570 else {
1571 query.append(ORDER_BY_DESC_HAS_NEXT);
1572 }
1573 }
1574 else {
1575 if (orderByComparator.isAscending() ^ previous) {
1576 query.append(ORDER_BY_ASC);
1577 }
1578 else {
1579 query.append(ORDER_BY_DESC);
1580 }
1581 }
1582 }
1583 }
1584
1585 else {
1586 query.append(BlogsStatsUserModelImpl.ORDER_BY_JPQL);
1587 }
1588
1589 String sql = query.toString();
1590
1591 Query q = session.createQuery(sql);
1592
1593 q.setFirstResult(0);
1594 q.setMaxResults(2);
1595
1596 QueryPos qPos = QueryPos.getInstance(q);
1597
1598 qPos.add(companyId);
1599
1600 qPos.add(entryCount);
1601
1602 if (orderByComparator != null) {
1603 Object[] values = orderByComparator.getOrderByValues(blogsStatsUser);
1604
1605 for (Object value : values) {
1606 qPos.add(value);
1607 }
1608 }
1609
1610 List<BlogsStatsUser> list = q.list();
1611
1612 if (list.size() == 2) {
1613 return list.get(1);
1614 }
1615 else {
1616 return null;
1617 }
1618 }
1619
1620 public List<BlogsStatsUser> findAll() throws SystemException {
1621 return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1622 }
1623
1624 public List<BlogsStatsUser> findAll(int start, int end)
1625 throws SystemException {
1626 return findAll(start, end, null);
1627 }
1628
1629 public List<BlogsStatsUser> findAll(int start, int end,
1630 OrderByComparator orderByComparator) throws SystemException {
1631 Object[] finderArgs = new Object[] {
1632 String.valueOf(start), String.valueOf(end),
1633 String.valueOf(orderByComparator)
1634 };
1635
1636 List<BlogsStatsUser> list = (List<BlogsStatsUser>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
1637 finderArgs, this);
1638
1639 if (list == null) {
1640 Session session = null;
1641
1642 try {
1643 session = openSession();
1644
1645 StringBundler query = null;
1646 String sql = null;
1647
1648 if (orderByComparator != null) {
1649 query = new StringBundler(2 +
1650 (orderByComparator.getOrderByFields().length * 3));
1651
1652 query.append(_SQL_SELECT_BLOGSSTATSUSER);
1653
1654 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1655 orderByComparator);
1656
1657 sql = query.toString();
1658 }
1659
1660 else {
1661 sql = _SQL_SELECT_BLOGSSTATSUSER.concat(BlogsStatsUserModelImpl.ORDER_BY_JPQL);
1662 }
1663
1664 Query q = session.createQuery(sql);
1665
1666 if (orderByComparator == null) {
1667 list = (List<BlogsStatsUser>)QueryUtil.list(q,
1668 getDialect(), start, end, false);
1669
1670 Collections.sort(list);
1671 }
1672 else {
1673 list = (List<BlogsStatsUser>)QueryUtil.list(q,
1674 getDialect(), start, end);
1675 }
1676 }
1677 catch (Exception e) {
1678 throw processException(e);
1679 }
1680 finally {
1681 if (list == null) {
1682 list = new ArrayList<BlogsStatsUser>();
1683 }
1684
1685 cacheResult(list);
1686
1687 FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
1688
1689 closeSession(session);
1690 }
1691 }
1692
1693 return list;
1694 }
1695
1696 public void removeByGroupId(long groupId) throws SystemException {
1697 for (BlogsStatsUser blogsStatsUser : findByGroupId(groupId)) {
1698 remove(blogsStatsUser);
1699 }
1700 }
1701
1702 public void removeByUserId(long userId) throws SystemException {
1703 for (BlogsStatsUser blogsStatsUser : findByUserId(userId)) {
1704 remove(blogsStatsUser);
1705 }
1706 }
1707
1708 public void removeByG_U(long groupId, long userId)
1709 throws NoSuchStatsUserException, SystemException {
1710 BlogsStatsUser blogsStatsUser = findByG_U(groupId, userId);
1711
1712 remove(blogsStatsUser);
1713 }
1714
1715 public void removeByG_E(long groupId, int entryCount)
1716 throws SystemException {
1717 for (BlogsStatsUser blogsStatsUser : findByG_E(groupId, entryCount)) {
1718 remove(blogsStatsUser);
1719 }
1720 }
1721
1722 public void removeByC_E(long companyId, int entryCount)
1723 throws SystemException {
1724 for (BlogsStatsUser blogsStatsUser : findByC_E(companyId, entryCount)) {
1725 remove(blogsStatsUser);
1726 }
1727 }
1728
1729 public void removeAll() throws SystemException {
1730 for (BlogsStatsUser blogsStatsUser : findAll()) {
1731 remove(blogsStatsUser);
1732 }
1733 }
1734
1735 public int countByGroupId(long groupId) throws SystemException {
1736 Object[] finderArgs = new Object[] { new Long(groupId) };
1737
1738 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_GROUPID,
1739 finderArgs, this);
1740
1741 if (count == null) {
1742 Session session = null;
1743
1744 try {
1745 session = openSession();
1746
1747 StringBundler query = new StringBundler(2);
1748
1749 query.append(_SQL_COUNT_BLOGSSTATSUSER_WHERE);
1750
1751 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1752
1753 String sql = query.toString();
1754
1755 Query q = session.createQuery(sql);
1756
1757 QueryPos qPos = QueryPos.getInstance(q);
1758
1759 qPos.add(groupId);
1760
1761 count = (Long)q.uniqueResult();
1762 }
1763 catch (Exception e) {
1764 throw processException(e);
1765 }
1766 finally {
1767 if (count == null) {
1768 count = Long.valueOf(0);
1769 }
1770
1771 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_GROUPID,
1772 finderArgs, count);
1773
1774 closeSession(session);
1775 }
1776 }
1777
1778 return count.intValue();
1779 }
1780
1781 public int countByUserId(long userId) throws SystemException {
1782 Object[] finderArgs = new Object[] { new Long(userId) };
1783
1784 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_USERID,
1785 finderArgs, this);
1786
1787 if (count == null) {
1788 Session session = null;
1789
1790 try {
1791 session = openSession();
1792
1793 StringBundler query = new StringBundler(2);
1794
1795 query.append(_SQL_COUNT_BLOGSSTATSUSER_WHERE);
1796
1797 query.append(_FINDER_COLUMN_USERID_USERID_2);
1798
1799 String sql = query.toString();
1800
1801 Query q = session.createQuery(sql);
1802
1803 QueryPos qPos = QueryPos.getInstance(q);
1804
1805 qPos.add(userId);
1806
1807 count = (Long)q.uniqueResult();
1808 }
1809 catch (Exception e) {
1810 throw processException(e);
1811 }
1812 finally {
1813 if (count == null) {
1814 count = Long.valueOf(0);
1815 }
1816
1817 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_USERID,
1818 finderArgs, count);
1819
1820 closeSession(session);
1821 }
1822 }
1823
1824 return count.intValue();
1825 }
1826
1827 public int countByG_U(long groupId, long userId) throws SystemException {
1828 Object[] finderArgs = new Object[] { new Long(groupId), new Long(userId) };
1829
1830 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_U,
1831 finderArgs, this);
1832
1833 if (count == null) {
1834 Session session = null;
1835
1836 try {
1837 session = openSession();
1838
1839 StringBundler query = new StringBundler(3);
1840
1841 query.append(_SQL_COUNT_BLOGSSTATSUSER_WHERE);
1842
1843 query.append(_FINDER_COLUMN_G_U_GROUPID_2);
1844
1845 query.append(_FINDER_COLUMN_G_U_USERID_2);
1846
1847 String sql = query.toString();
1848
1849 Query q = session.createQuery(sql);
1850
1851 QueryPos qPos = QueryPos.getInstance(q);
1852
1853 qPos.add(groupId);
1854
1855 qPos.add(userId);
1856
1857 count = (Long)q.uniqueResult();
1858 }
1859 catch (Exception e) {
1860 throw processException(e);
1861 }
1862 finally {
1863 if (count == null) {
1864 count = Long.valueOf(0);
1865 }
1866
1867 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_U, finderArgs,
1868 count);
1869
1870 closeSession(session);
1871 }
1872 }
1873
1874 return count.intValue();
1875 }
1876
1877 public int countByG_E(long groupId, int entryCount)
1878 throws SystemException {
1879 Object[] finderArgs = new Object[] {
1880 new Long(groupId), new Integer(entryCount)
1881 };
1882
1883 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_E,
1884 finderArgs, this);
1885
1886 if (count == null) {
1887 Session session = null;
1888
1889 try {
1890 session = openSession();
1891
1892 StringBundler query = new StringBundler(3);
1893
1894 query.append(_SQL_COUNT_BLOGSSTATSUSER_WHERE);
1895
1896 query.append(_FINDER_COLUMN_G_E_GROUPID_2);
1897
1898 query.append(_FINDER_COLUMN_G_E_ENTRYCOUNT_2);
1899
1900 String sql = query.toString();
1901
1902 Query q = session.createQuery(sql);
1903
1904 QueryPos qPos = QueryPos.getInstance(q);
1905
1906 qPos.add(groupId);
1907
1908 qPos.add(entryCount);
1909
1910 count = (Long)q.uniqueResult();
1911 }
1912 catch (Exception e) {
1913 throw processException(e);
1914 }
1915 finally {
1916 if (count == null) {
1917 count = Long.valueOf(0);
1918 }
1919
1920 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_E, finderArgs,
1921 count);
1922
1923 closeSession(session);
1924 }
1925 }
1926
1927 return count.intValue();
1928 }
1929
1930 public int countByC_E(long companyId, int entryCount)
1931 throws SystemException {
1932 Object[] finderArgs = new Object[] {
1933 new Long(companyId), new Integer(entryCount)
1934 };
1935
1936 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_E,
1937 finderArgs, this);
1938
1939 if (count == null) {
1940 Session session = null;
1941
1942 try {
1943 session = openSession();
1944
1945 StringBundler query = new StringBundler(3);
1946
1947 query.append(_SQL_COUNT_BLOGSSTATSUSER_WHERE);
1948
1949 query.append(_FINDER_COLUMN_C_E_COMPANYID_2);
1950
1951 query.append(_FINDER_COLUMN_C_E_ENTRYCOUNT_2);
1952
1953 String sql = query.toString();
1954
1955 Query q = session.createQuery(sql);
1956
1957 QueryPos qPos = QueryPos.getInstance(q);
1958
1959 qPos.add(companyId);
1960
1961 qPos.add(entryCount);
1962
1963 count = (Long)q.uniqueResult();
1964 }
1965 catch (Exception e) {
1966 throw processException(e);
1967 }
1968 finally {
1969 if (count == null) {
1970 count = Long.valueOf(0);
1971 }
1972
1973 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_E, finderArgs,
1974 count);
1975
1976 closeSession(session);
1977 }
1978 }
1979
1980 return count.intValue();
1981 }
1982
1983 public int countAll() throws SystemException {
1984 Object[] finderArgs = new Object[0];
1985
1986 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
1987 finderArgs, this);
1988
1989 if (count == null) {
1990 Session session = null;
1991
1992 try {
1993 session = openSession();
1994
1995 Query q = session.createQuery(_SQL_COUNT_BLOGSSTATSUSER);
1996
1997 count = (Long)q.uniqueResult();
1998 }
1999 catch (Exception e) {
2000 throw processException(e);
2001 }
2002 finally {
2003 if (count == null) {
2004 count = Long.valueOf(0);
2005 }
2006
2007 FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
2008 count);
2009
2010 closeSession(session);
2011 }
2012 }
2013
2014 return count.intValue();
2015 }
2016
2017 public void afterPropertiesSet() {
2018 String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
2019 com.liferay.portal.util.PropsUtil.get(
2020 "value.object.listener.com.liferay.portlet.blogs.model.BlogsStatsUser")));
2021
2022 if (listenerClassNames.length > 0) {
2023 try {
2024 List<ModelListener<BlogsStatsUser>> listenersList = new ArrayList<ModelListener<BlogsStatsUser>>();
2025
2026 for (String listenerClassName : listenerClassNames) {
2027 listenersList.add((ModelListener<BlogsStatsUser>)InstanceFactory.newInstance(
2028 listenerClassName));
2029 }
2030
2031 listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
2032 }
2033 catch (Exception e) {
2034 _log.error(e);
2035 }
2036 }
2037 }
2038
2039 @BeanReference(type = BlogsEntryPersistence.class)
2040 protected BlogsEntryPersistence blogsEntryPersistence;
2041 @BeanReference(type = BlogsStatsUserPersistence.class)
2042 protected BlogsStatsUserPersistence blogsStatsUserPersistence;
2043 @BeanReference(type = GroupPersistence.class)
2044 protected GroupPersistence groupPersistence;
2045 @BeanReference(type = ResourcePersistence.class)
2046 protected ResourcePersistence resourcePersistence;
2047 @BeanReference(type = UserPersistence.class)
2048 protected UserPersistence userPersistence;
2049 private static final String _SQL_SELECT_BLOGSSTATSUSER = "SELECT blogsStatsUser FROM BlogsStatsUser blogsStatsUser";
2050 private static final String _SQL_SELECT_BLOGSSTATSUSER_WHERE = "SELECT blogsStatsUser FROM BlogsStatsUser blogsStatsUser WHERE ";
2051 private static final String _SQL_COUNT_BLOGSSTATSUSER = "SELECT COUNT(blogsStatsUser) FROM BlogsStatsUser blogsStatsUser";
2052 private static final String _SQL_COUNT_BLOGSSTATSUSER_WHERE = "SELECT COUNT(blogsStatsUser) FROM BlogsStatsUser blogsStatsUser WHERE ";
2053 private static final String _FINDER_COLUMN_GROUPID_GROUPID_2 = "blogsStatsUser.groupId = ?";
2054 private static final String _FINDER_COLUMN_USERID_USERID_2 = "blogsStatsUser.userId = ?";
2055 private static final String _FINDER_COLUMN_G_U_GROUPID_2 = "blogsStatsUser.groupId = ? AND ";
2056 private static final String _FINDER_COLUMN_G_U_USERID_2 = "blogsStatsUser.userId = ?";
2057 private static final String _FINDER_COLUMN_G_E_GROUPID_2 = "blogsStatsUser.groupId = ? AND ";
2058 private static final String _FINDER_COLUMN_G_E_ENTRYCOUNT_2 = "blogsStatsUser.entryCount != ?";
2059 private static final String _FINDER_COLUMN_C_E_COMPANYID_2 = "blogsStatsUser.companyId = ? AND ";
2060 private static final String _FINDER_COLUMN_C_E_ENTRYCOUNT_2 = "blogsStatsUser.entryCount != ?";
2061 private static final String _ORDER_BY_ENTITY_ALIAS = "blogsStatsUser.";
2062 private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No BlogsStatsUser exists with the primary key ";
2063 private static final String _NO_SUCH_ENTITY_WITH_KEY = "No BlogsStatsUser exists with the key {";
2064 private static Log _log = LogFactoryUtil.getLog(BlogsStatsUserPersistenceImpl.class);
2065}