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