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