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