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