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