1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * This library is free software; you can redistribute it and/or modify it under
5    * the terms of the GNU Lesser General Public License as published by the Free
6    * Software Foundation; either version 2.1 of the License, or (at your option)
7    * any later version.
8    *
9    * This library is distributed in the hope that it will be useful, but WITHOUT
10   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11   * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
12   * details.
13   */
14  
15  package com.liferay.portlet.blogs.service.persistence;
16  
17  import com.liferay.portal.NoSuchModelException;
18  import com.liferay.portal.kernel.annotation.BeanReference;
19  import com.liferay.portal.kernel.cache.CacheRegistry;
20  import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
21  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
22  import com.liferay.portal.kernel.dao.orm.FinderPath;
23  import com.liferay.portal.kernel.dao.orm.Query;
24  import com.liferay.portal.kernel.dao.orm.QueryPos;
25  import com.liferay.portal.kernel.dao.orm.QueryUtil;
26  import com.liferay.portal.kernel.dao.orm.SQLQuery;
27  import com.liferay.portal.kernel.dao.orm.Session;
28  import com.liferay.portal.kernel.dao.orm.Type;
29  import com.liferay.portal.kernel.exception.SystemException;
30  import com.liferay.portal.kernel.log.Log;
31  import com.liferay.portal.kernel.log.LogFactoryUtil;
32  import com.liferay.portal.kernel.sanitizer.Sanitizer;
33  import com.liferay.portal.kernel.sanitizer.SanitizerException;
34  import com.liferay.portal.kernel.sanitizer.SanitizerUtil;
35  import com.liferay.portal.kernel.util.CalendarUtil;
36  import com.liferay.portal.kernel.util.ContentTypes;
37  import com.liferay.portal.kernel.util.GetterUtil;
38  import com.liferay.portal.kernel.util.InstanceFactory;
39  import com.liferay.portal.kernel.util.OrderByComparator;
40  import com.liferay.portal.kernel.util.StringBundler;
41  import com.liferay.portal.kernel.util.StringPool;
42  import com.liferay.portal.kernel.util.StringUtil;
43  import com.liferay.portal.kernel.util.Validator;
44  import com.liferay.portal.kernel.uuid.PortalUUIDUtil;
45  import com.liferay.portal.model.ModelListener;
46  import com.liferay.portal.security.auth.PrincipalThreadLocal;
47  import com.liferay.portal.security.permission.InlineSQLHelperUtil;
48  import com.liferay.portal.service.persistence.BatchSessionUtil;
49  import com.liferay.portal.service.persistence.CompanyPersistence;
50  import com.liferay.portal.service.persistence.GroupPersistence;
51  import com.liferay.portal.service.persistence.OrganizationPersistence;
52  import com.liferay.portal.service.persistence.PortletPreferencesPersistence;
53  import com.liferay.portal.service.persistence.ResourcePersistence;
54  import com.liferay.portal.service.persistence.UserPersistence;
55  import com.liferay.portal.service.persistence.WorkflowInstanceLinkPersistence;
56  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
57  
58  import com.liferay.portlet.asset.service.persistence.AssetEntryPersistence;
59  import com.liferay.portlet.asset.service.persistence.AssetTagPersistence;
60  import com.liferay.portlet.blogs.NoSuchEntryException;
61  import com.liferay.portlet.blogs.model.BlogsEntry;
62  import com.liferay.portlet.blogs.model.impl.BlogsEntryImpl;
63  import com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl;
64  import com.liferay.portlet.expando.service.persistence.ExpandoValuePersistence;
65  import com.liferay.portlet.messageboards.service.persistence.MBMessagePersistence;
66  import com.liferay.portlet.ratings.service.persistence.RatingsStatsPersistence;
67  import com.liferay.portlet.social.service.persistence.SocialActivityPersistence;
68  
69  import java.io.Serializable;
70  
71  import java.util.ArrayList;
72  import java.util.Collections;
73  import java.util.Date;
74  import java.util.List;
75  
76  /**
77   * <a href="BlogsEntryPersistenceImpl.java.html"><b><i>View Source</i></b></a>
78   *
79   * <p>
80   * ServiceBuilder generated this class. Modifications in this class will be
81   * overwritten the next time is generated.
82   * </p>
83   *
84   * @author    Brian Wing Shun Chan
85   * @see       BlogsEntryPersistence
86   * @see       BlogsEntryUtil
87   * @generated
88   */
89  public class BlogsEntryPersistenceImpl extends BasePersistenceImpl<BlogsEntry>
90      implements BlogsEntryPersistence {
91      public static final String FINDER_CLASS_NAME_ENTITY = BlogsEntryImpl.class.getName();
92      public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
93          ".List";
94      public static final FinderPath FINDER_PATH_FIND_BY_UUID = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
95              BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
96              "findByUuid",
97              new String[] {
98                  String.class.getName(),
99                  
100             "java.lang.Integer", "java.lang.Integer",
101                 "com.liferay.portal.kernel.util.OrderByComparator"
102             });
103     public static final FinderPath FINDER_PATH_COUNT_BY_UUID = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
104             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
105             "countByUuid", new String[] { String.class.getName() });
106     public static final FinderPath FINDER_PATH_FETCH_BY_UUID_G = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
107             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_ENTITY,
108             "fetchByUUID_G",
109             new String[] { String.class.getName(), Long.class.getName() });
110     public static final FinderPath FINDER_PATH_COUNT_BY_UUID_G = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
111             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
112             "countByUUID_G",
113             new String[] { String.class.getName(), Long.class.getName() });
114     public static final FinderPath FINDER_PATH_FIND_BY_GROUPID = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
115             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
116             "findByGroupId",
117             new String[] {
118                 Long.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_GROUPID = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
124             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
125             "countByGroupId", new String[] { Long.class.getName() });
126     public static final FinderPath FINDER_PATH_FIND_BY_COMPANYID = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
127             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
128             "findByCompanyId",
129             new String[] {
130                 Long.class.getName(),
131                 
132             "java.lang.Integer", "java.lang.Integer",
133                 "com.liferay.portal.kernel.util.OrderByComparator"
134             });
135     public static final FinderPath FINDER_PATH_COUNT_BY_COMPANYID = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
136             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
137             "countByCompanyId", new String[] { Long.class.getName() });
138     public static final FinderPath FINDER_PATH_FIND_BY_C_U = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
139             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
140             "findByC_U",
141             new String[] {
142                 Long.class.getName(), Long.class.getName(),
143                 
144             "java.lang.Integer", "java.lang.Integer",
145                 "com.liferay.portal.kernel.util.OrderByComparator"
146             });
147     public static final FinderPath FINDER_PATH_COUNT_BY_C_U = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
148             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
149             "countByC_U",
150             new String[] { Long.class.getName(), Long.class.getName() });
151     public static final FinderPath FINDER_PATH_FIND_BY_C_D = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
152             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
153             "findByC_D",
154             new String[] {
155                 Long.class.getName(), Date.class.getName(),
156                 
157             "java.lang.Integer", "java.lang.Integer",
158                 "com.liferay.portal.kernel.util.OrderByComparator"
159             });
160     public static final FinderPath FINDER_PATH_COUNT_BY_C_D = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
161             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
162             "countByC_D",
163             new String[] { Long.class.getName(), Date.class.getName() });
164     public static final FinderPath FINDER_PATH_FIND_BY_C_S = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
165             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
166             "findByC_S",
167             new String[] {
168                 Long.class.getName(), Integer.class.getName(),
169                 
170             "java.lang.Integer", "java.lang.Integer",
171                 "com.liferay.portal.kernel.util.OrderByComparator"
172             });
173     public static final FinderPath FINDER_PATH_COUNT_BY_C_S = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
174             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
175             "countByC_S",
176             new String[] { Long.class.getName(), Integer.class.getName() });
177     public static final FinderPath FINDER_PATH_FETCH_BY_G_UT = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
178             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_ENTITY,
179             "fetchByG_UT",
180             new String[] { Long.class.getName(), String.class.getName() });
181     public static final FinderPath FINDER_PATH_COUNT_BY_G_UT = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
182             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
183             "countByG_UT",
184             new String[] { Long.class.getName(), String.class.getName() });
185     public static final FinderPath FINDER_PATH_FIND_BY_G_D = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
186             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
187             "findByG_D",
188             new String[] {
189                 Long.class.getName(), Date.class.getName(),
190                 
191             "java.lang.Integer", "java.lang.Integer",
192                 "com.liferay.portal.kernel.util.OrderByComparator"
193             });
194     public static final FinderPath FINDER_PATH_COUNT_BY_G_D = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
195             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
196             "countByG_D",
197             new String[] { Long.class.getName(), Date.class.getName() });
198     public static final FinderPath FINDER_PATH_FIND_BY_G_S = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
199             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
200             "findByG_S",
201             new String[] {
202                 Long.class.getName(), Integer.class.getName(),
203                 
204             "java.lang.Integer", "java.lang.Integer",
205                 "com.liferay.portal.kernel.util.OrderByComparator"
206             });
207     public static final FinderPath FINDER_PATH_COUNT_BY_G_S = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
208             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
209             "countByG_S",
210             new String[] { Long.class.getName(), Integer.class.getName() });
211     public static final FinderPath FINDER_PATH_FIND_BY_C_U_S = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
212             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
213             "findByC_U_S",
214             new String[] {
215                 Long.class.getName(), Long.class.getName(),
216                 Integer.class.getName(),
217                 
218             "java.lang.Integer", "java.lang.Integer",
219                 "com.liferay.portal.kernel.util.OrderByComparator"
220             });
221     public static final FinderPath FINDER_PATH_COUNT_BY_C_U_S = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
222             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
223             "countByC_U_S",
224             new String[] {
225                 Long.class.getName(), Long.class.getName(),
226                 Integer.class.getName()
227             });
228     public static final FinderPath FINDER_PATH_FIND_BY_C_D_S = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
229             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
230             "findByC_D_S",
231             new String[] {
232                 Long.class.getName(), Date.class.getName(),
233                 Integer.class.getName(),
234                 
235             "java.lang.Integer", "java.lang.Integer",
236                 "com.liferay.portal.kernel.util.OrderByComparator"
237             });
238     public static final FinderPath FINDER_PATH_COUNT_BY_C_D_S = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
239             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
240             "countByC_D_S",
241             new String[] {
242                 Long.class.getName(), Date.class.getName(),
243                 Integer.class.getName()
244             });
245     public static final FinderPath FINDER_PATH_FIND_BY_G_U_D = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
246             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
247             "findByG_U_D",
248             new String[] {
249                 Long.class.getName(), Long.class.getName(), Date.class.getName(),
250                 
251             "java.lang.Integer", "java.lang.Integer",
252                 "com.liferay.portal.kernel.util.OrderByComparator"
253             });
254     public static final FinderPath FINDER_PATH_COUNT_BY_G_U_D = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
255             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
256             "countByG_U_D",
257             new String[] {
258                 Long.class.getName(), Long.class.getName(), Date.class.getName()
259             });
260     public static final FinderPath FINDER_PATH_FIND_BY_G_U_S = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
261             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
262             "findByG_U_S",
263             new String[] {
264                 Long.class.getName(), Long.class.getName(),
265                 Integer.class.getName(),
266                 
267             "java.lang.Integer", "java.lang.Integer",
268                 "com.liferay.portal.kernel.util.OrderByComparator"
269             });
270     public static final FinderPath FINDER_PATH_COUNT_BY_G_U_S = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
271             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
272             "countByG_U_S",
273             new String[] {
274                 Long.class.getName(), Long.class.getName(),
275                 Integer.class.getName()
276             });
277     public static final FinderPath FINDER_PATH_FIND_BY_G_D_S = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
278             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
279             "findByG_D_S",
280             new String[] {
281                 Long.class.getName(), Date.class.getName(),
282                 Integer.class.getName(),
283                 
284             "java.lang.Integer", "java.lang.Integer",
285                 "com.liferay.portal.kernel.util.OrderByComparator"
286             });
287     public static final FinderPath FINDER_PATH_COUNT_BY_G_D_S = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
288             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
289             "countByG_D_S",
290             new String[] {
291                 Long.class.getName(), Date.class.getName(),
292                 Integer.class.getName()
293             });
294     public static final FinderPath FINDER_PATH_FIND_BY_G_U_D_S = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
295             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
296             "findByG_U_D_S",
297             new String[] {
298                 Long.class.getName(), Long.class.getName(), Date.class.getName(),
299                 Integer.class.getName(),
300                 
301             "java.lang.Integer", "java.lang.Integer",
302                 "com.liferay.portal.kernel.util.OrderByComparator"
303             });
304     public static final FinderPath FINDER_PATH_COUNT_BY_G_U_D_S = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
305             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
306             "countByG_U_D_S",
307             new String[] {
308                 Long.class.getName(), Long.class.getName(), Date.class.getName(),
309                 Integer.class.getName()
310             });
311     public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
312             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
313             "findAll", new String[0]);
314     public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
315             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
316             "countAll", new String[0]);
317 
318     public void cacheResult(BlogsEntry blogsEntry) {
319         EntityCacheUtil.putResult(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
320             BlogsEntryImpl.class, blogsEntry.getPrimaryKey(), blogsEntry);
321 
322         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
323             new Object[] { blogsEntry.getUuid(), new Long(
324                     blogsEntry.getGroupId()) }, blogsEntry);
325 
326         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_UT,
327             new Object[] {
328                 new Long(blogsEntry.getGroupId()),
329                 
330             blogsEntry.getUrlTitle()
331             }, blogsEntry);
332     }
333 
334     public void cacheResult(List<BlogsEntry> blogsEntries) {
335         for (BlogsEntry blogsEntry : blogsEntries) {
336             if (EntityCacheUtil.getResult(
337                         BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
338                         BlogsEntryImpl.class, blogsEntry.getPrimaryKey(), this) == null) {
339                 cacheResult(blogsEntry);
340             }
341         }
342     }
343 
344     public void clearCache() {
345         CacheRegistry.clear(BlogsEntryImpl.class.getName());
346         EntityCacheUtil.clearCache(BlogsEntryImpl.class.getName());
347         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
348         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
349     }
350 
351     public void clearCache(BlogsEntry blogsEntry) {
352         EntityCacheUtil.removeResult(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
353             BlogsEntryImpl.class, blogsEntry.getPrimaryKey());
354 
355         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
356             new Object[] { blogsEntry.getUuid(), new Long(
357                     blogsEntry.getGroupId()) });
358 
359         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_UT,
360             new Object[] {
361                 new Long(blogsEntry.getGroupId()),
362                 
363             blogsEntry.getUrlTitle()
364             });
365     }
366 
367     public BlogsEntry create(long entryId) {
368         BlogsEntry blogsEntry = new BlogsEntryImpl();
369 
370         blogsEntry.setNew(true);
371         blogsEntry.setPrimaryKey(entryId);
372 
373         String uuid = PortalUUIDUtil.generate();
374 
375         blogsEntry.setUuid(uuid);
376 
377         return blogsEntry;
378     }
379 
380     public BlogsEntry remove(Serializable primaryKey)
381         throws NoSuchModelException, SystemException {
382         return remove(((Long)primaryKey).longValue());
383     }
384 
385     public BlogsEntry remove(long entryId)
386         throws NoSuchEntryException, SystemException {
387         Session session = null;
388 
389         try {
390             session = openSession();
391 
392             BlogsEntry blogsEntry = (BlogsEntry)session.get(BlogsEntryImpl.class,
393                     new Long(entryId));
394 
395             if (blogsEntry == null) {
396                 if (_log.isWarnEnabled()) {
397                     _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + entryId);
398                 }
399 
400                 throw new NoSuchEntryException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
401                     entryId);
402             }
403 
404             return remove(blogsEntry);
405         }
406         catch (NoSuchEntryException nsee) {
407             throw nsee;
408         }
409         catch (Exception e) {
410             throw processException(e);
411         }
412         finally {
413             closeSession(session);
414         }
415     }
416 
417     public BlogsEntry remove(BlogsEntry blogsEntry) throws SystemException {
418         for (ModelListener<BlogsEntry> listener : listeners) {
419             listener.onBeforeRemove(blogsEntry);
420         }
421 
422         blogsEntry = removeImpl(blogsEntry);
423 
424         for (ModelListener<BlogsEntry> listener : listeners) {
425             listener.onAfterRemove(blogsEntry);
426         }
427 
428         return blogsEntry;
429     }
430 
431     protected BlogsEntry removeImpl(BlogsEntry blogsEntry)
432         throws SystemException {
433         blogsEntry = toUnwrappedModel(blogsEntry);
434 
435         Session session = null;
436 
437         try {
438             session = openSession();
439 
440             if (blogsEntry.isCachedModel() || BatchSessionUtil.isEnabled()) {
441                 Object staleObject = session.get(BlogsEntryImpl.class,
442                         blogsEntry.getPrimaryKeyObj());
443 
444                 if (staleObject != null) {
445                     session.evict(staleObject);
446                 }
447             }
448 
449             session.delete(blogsEntry);
450 
451             session.flush();
452         }
453         catch (Exception e) {
454             throw processException(e);
455         }
456         finally {
457             closeSession(session);
458         }
459 
460         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
461 
462         BlogsEntryModelImpl blogsEntryModelImpl = (BlogsEntryModelImpl)blogsEntry;
463 
464         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
465             new Object[] {
466                 blogsEntryModelImpl.getOriginalUuid(),
467                 new Long(blogsEntryModelImpl.getOriginalGroupId())
468             });
469 
470         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_UT,
471             new Object[] {
472                 new Long(blogsEntryModelImpl.getOriginalGroupId()),
473                 
474             blogsEntryModelImpl.getOriginalUrlTitle()
475             });
476 
477         EntityCacheUtil.removeResult(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
478             BlogsEntryImpl.class, blogsEntry.getPrimaryKey());
479 
480         return blogsEntry;
481     }
482 
483     public BlogsEntry updateImpl(
484         com.liferay.portlet.blogs.model.BlogsEntry blogsEntry, boolean merge)
485         throws SystemException {
486         blogsEntry = toUnwrappedModel(blogsEntry);
487 
488         boolean isNew = blogsEntry.isNew();
489 
490         BlogsEntryModelImpl blogsEntryModelImpl = (BlogsEntryModelImpl)blogsEntry;
491 
492         if (Validator.isNull(blogsEntry.getUuid())) {
493             String uuid = PortalUUIDUtil.generate();
494 
495             blogsEntry.setUuid(uuid);
496         }
497 
498         long userId = GetterUtil.getLong(PrincipalThreadLocal.getName());
499 
500         if (userId > 0) {
501             long companyId = blogsEntry.getCompanyId();
502 
503             long groupId = blogsEntry.getGroupId();
504 
505             long entryId = 0;
506 
507             if (!isNew) {
508                 entryId = blogsEntry.getPrimaryKey();
509             }
510 
511             try {
512                 blogsEntry.setTitle(SanitizerUtil.sanitize(companyId, groupId,
513                         userId,
514                         com.liferay.portlet.blogs.model.BlogsEntry.class.getName(),
515                         entryId, ContentTypes.TEXT_PLAIN, Sanitizer.MODE_ALL,
516                         blogsEntry.getTitle(), null));
517 
518                 blogsEntry.setContent(SanitizerUtil.sanitize(companyId,
519                         groupId, userId,
520                         com.liferay.portlet.blogs.model.BlogsEntry.class.getName(),
521                         entryId, ContentTypes.TEXT_HTML, Sanitizer.MODE_ALL,
522                         blogsEntry.getContent(), null));
523             }
524             catch (SanitizerException se) {
525                 throw new SystemException(se);
526             }
527         }
528 
529         Session session = null;
530 
531         try {
532             session = openSession();
533 
534             BatchSessionUtil.update(session, blogsEntry, merge);
535 
536             blogsEntry.setNew(false);
537         }
538         catch (Exception e) {
539             throw processException(e);
540         }
541         finally {
542             closeSession(session);
543         }
544 
545         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
546 
547         EntityCacheUtil.putResult(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
548             BlogsEntryImpl.class, blogsEntry.getPrimaryKey(), blogsEntry);
549 
550         if (!isNew &&
551                 (!Validator.equals(blogsEntry.getUuid(),
552                     blogsEntryModelImpl.getOriginalUuid()) ||
553                 (blogsEntry.getGroupId() != blogsEntryModelImpl.getOriginalGroupId()))) {
554             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
555                 new Object[] {
556                     blogsEntryModelImpl.getOriginalUuid(),
557                     new Long(blogsEntryModelImpl.getOriginalGroupId())
558                 });
559         }
560 
561         if (isNew ||
562                 (!Validator.equals(blogsEntry.getUuid(),
563                     blogsEntryModelImpl.getOriginalUuid()) ||
564                 (blogsEntry.getGroupId() != blogsEntryModelImpl.getOriginalGroupId()))) {
565             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
566                 new Object[] {
567                     blogsEntry.getUuid(), new Long(blogsEntry.getGroupId())
568                 }, blogsEntry);
569         }
570 
571         if (!isNew &&
572                 ((blogsEntry.getGroupId() != blogsEntryModelImpl.getOriginalGroupId()) ||
573                 !Validator.equals(blogsEntry.getUrlTitle(),
574                     blogsEntryModelImpl.getOriginalUrlTitle()))) {
575             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_UT,
576                 new Object[] {
577                     new Long(blogsEntryModelImpl.getOriginalGroupId()),
578                     
579                 blogsEntryModelImpl.getOriginalUrlTitle()
580                 });
581         }
582 
583         if (isNew ||
584                 ((blogsEntry.getGroupId() != blogsEntryModelImpl.getOriginalGroupId()) ||
585                 !Validator.equals(blogsEntry.getUrlTitle(),
586                     blogsEntryModelImpl.getOriginalUrlTitle()))) {
587             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_UT,
588                 new Object[] {
589                     new Long(blogsEntry.getGroupId()),
590                     
591                 blogsEntry.getUrlTitle()
592                 }, blogsEntry);
593         }
594 
595         return blogsEntry;
596     }
597 
598     protected BlogsEntry toUnwrappedModel(BlogsEntry blogsEntry) {
599         if (blogsEntry instanceof BlogsEntryImpl) {
600             return blogsEntry;
601         }
602 
603         BlogsEntryImpl blogsEntryImpl = new BlogsEntryImpl();
604 
605         blogsEntryImpl.setNew(blogsEntry.isNew());
606         blogsEntryImpl.setPrimaryKey(blogsEntry.getPrimaryKey());
607 
608         blogsEntryImpl.setUuid(blogsEntry.getUuid());
609         blogsEntryImpl.setEntryId(blogsEntry.getEntryId());
610         blogsEntryImpl.setGroupId(blogsEntry.getGroupId());
611         blogsEntryImpl.setCompanyId(blogsEntry.getCompanyId());
612         blogsEntryImpl.setUserId(blogsEntry.getUserId());
613         blogsEntryImpl.setUserName(blogsEntry.getUserName());
614         blogsEntryImpl.setCreateDate(blogsEntry.getCreateDate());
615         blogsEntryImpl.setModifiedDate(blogsEntry.getModifiedDate());
616         blogsEntryImpl.setTitle(blogsEntry.getTitle());
617         blogsEntryImpl.setUrlTitle(blogsEntry.getUrlTitle());
618         blogsEntryImpl.setContent(blogsEntry.getContent());
619         blogsEntryImpl.setDisplayDate(blogsEntry.getDisplayDate());
620         blogsEntryImpl.setAllowPingbacks(blogsEntry.isAllowPingbacks());
621         blogsEntryImpl.setAllowTrackbacks(blogsEntry.isAllowTrackbacks());
622         blogsEntryImpl.setTrackbacks(blogsEntry.getTrackbacks());
623         blogsEntryImpl.setStatus(blogsEntry.getStatus());
624         blogsEntryImpl.setStatusByUserId(blogsEntry.getStatusByUserId());
625         blogsEntryImpl.setStatusByUserName(blogsEntry.getStatusByUserName());
626         blogsEntryImpl.setStatusDate(blogsEntry.getStatusDate());
627 
628         return blogsEntryImpl;
629     }
630 
631     public BlogsEntry findByPrimaryKey(Serializable primaryKey)
632         throws NoSuchModelException, SystemException {
633         return findByPrimaryKey(((Long)primaryKey).longValue());
634     }
635 
636     public BlogsEntry findByPrimaryKey(long entryId)
637         throws NoSuchEntryException, SystemException {
638         BlogsEntry blogsEntry = fetchByPrimaryKey(entryId);
639 
640         if (blogsEntry == null) {
641             if (_log.isWarnEnabled()) {
642                 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + entryId);
643             }
644 
645             throw new NoSuchEntryException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
646                 entryId);
647         }
648 
649         return blogsEntry;
650     }
651 
652     public BlogsEntry fetchByPrimaryKey(Serializable primaryKey)
653         throws SystemException {
654         return fetchByPrimaryKey(((Long)primaryKey).longValue());
655     }
656 
657     public BlogsEntry fetchByPrimaryKey(long entryId) throws SystemException {
658         BlogsEntry blogsEntry = (BlogsEntry)EntityCacheUtil.getResult(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
659                 BlogsEntryImpl.class, entryId, this);
660 
661         if (blogsEntry == null) {
662             Session session = null;
663 
664             try {
665                 session = openSession();
666 
667                 blogsEntry = (BlogsEntry)session.get(BlogsEntryImpl.class,
668                         new Long(entryId));
669             }
670             catch (Exception e) {
671                 throw processException(e);
672             }
673             finally {
674                 if (blogsEntry != null) {
675                     cacheResult(blogsEntry);
676                 }
677 
678                 closeSession(session);
679             }
680         }
681 
682         return blogsEntry;
683     }
684 
685     public List<BlogsEntry> findByUuid(String uuid) throws SystemException {
686         return findByUuid(uuid, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
687     }
688 
689     public List<BlogsEntry> findByUuid(String uuid, int start, int end)
690         throws SystemException {
691         return findByUuid(uuid, start, end, null);
692     }
693 
694     public List<BlogsEntry> findByUuid(String uuid, int start, int end,
695         OrderByComparator orderByComparator) throws SystemException {
696         Object[] finderArgs = new Object[] {
697                 uuid,
698                 
699                 String.valueOf(start), String.valueOf(end),
700                 String.valueOf(orderByComparator)
701             };
702 
703         List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_UUID,
704                 finderArgs, this);
705 
706         if (list == null) {
707             Session session = null;
708 
709             try {
710                 session = openSession();
711 
712                 StringBundler query = null;
713 
714                 if (orderByComparator != null) {
715                     query = new StringBundler(3 +
716                             (orderByComparator.getOrderByFields().length * 3));
717                 }
718                 else {
719                     query = new StringBundler(3);
720                 }
721 
722                 query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
723 
724                 if (uuid == null) {
725                     query.append(_FINDER_COLUMN_UUID_UUID_1);
726                 }
727                 else {
728                     if (uuid.equals(StringPool.BLANK)) {
729                         query.append(_FINDER_COLUMN_UUID_UUID_3);
730                     }
731                     else {
732                         query.append(_FINDER_COLUMN_UUID_UUID_2);
733                     }
734                 }
735 
736                 if (orderByComparator != null) {
737                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
738                         orderByComparator);
739                 }
740 
741                 else {
742                     query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
743                 }
744 
745                 String sql = query.toString();
746 
747                 Query q = session.createQuery(sql);
748 
749                 QueryPos qPos = QueryPos.getInstance(q);
750 
751                 if (uuid != null) {
752                     qPos.add(uuid);
753                 }
754 
755                 list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start,
756                         end);
757             }
758             catch (Exception e) {
759                 throw processException(e);
760             }
761             finally {
762                 if (list == null) {
763                     list = new ArrayList<BlogsEntry>();
764                 }
765 
766                 cacheResult(list);
767 
768                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_UUID, finderArgs,
769                     list);
770 
771                 closeSession(session);
772             }
773         }
774 
775         return list;
776     }
777 
778     public BlogsEntry findByUuid_First(String uuid,
779         OrderByComparator orderByComparator)
780         throws NoSuchEntryException, SystemException {
781         List<BlogsEntry> list = findByUuid(uuid, 0, 1, orderByComparator);
782 
783         if (list.isEmpty()) {
784             StringBundler msg = new StringBundler(4);
785 
786             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
787 
788             msg.append("uuid=");
789             msg.append(uuid);
790 
791             msg.append(StringPool.CLOSE_CURLY_BRACE);
792 
793             throw new NoSuchEntryException(msg.toString());
794         }
795         else {
796             return list.get(0);
797         }
798     }
799 
800     public BlogsEntry findByUuid_Last(String uuid,
801         OrderByComparator orderByComparator)
802         throws NoSuchEntryException, SystemException {
803         int count = countByUuid(uuid);
804 
805         List<BlogsEntry> list = findByUuid(uuid, count - 1, count,
806                 orderByComparator);
807 
808         if (list.isEmpty()) {
809             StringBundler msg = new StringBundler(4);
810 
811             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
812 
813             msg.append("uuid=");
814             msg.append(uuid);
815 
816             msg.append(StringPool.CLOSE_CURLY_BRACE);
817 
818             throw new NoSuchEntryException(msg.toString());
819         }
820         else {
821             return list.get(0);
822         }
823     }
824 
825     public BlogsEntry[] findByUuid_PrevAndNext(long entryId, String uuid,
826         OrderByComparator orderByComparator)
827         throws NoSuchEntryException, SystemException {
828         BlogsEntry blogsEntry = findByPrimaryKey(entryId);
829 
830         Session session = null;
831 
832         try {
833             session = openSession();
834 
835             BlogsEntry[] array = new BlogsEntryImpl[3];
836 
837             array[0] = getByUuid_PrevAndNext(session, blogsEntry, uuid,
838                     orderByComparator, true);
839 
840             array[1] = blogsEntry;
841 
842             array[2] = getByUuid_PrevAndNext(session, blogsEntry, uuid,
843                     orderByComparator, false);
844 
845             return array;
846         }
847         catch (Exception e) {
848             throw processException(e);
849         }
850         finally {
851             closeSession(session);
852         }
853     }
854 
855     protected BlogsEntry getByUuid_PrevAndNext(Session session,
856         BlogsEntry blogsEntry, String uuid,
857         OrderByComparator orderByComparator, boolean previous) {
858         StringBundler query = null;
859 
860         if (orderByComparator != null) {
861             query = new StringBundler(6 +
862                     (orderByComparator.getOrderByFields().length * 6));
863         }
864         else {
865             query = new StringBundler(3);
866         }
867 
868         query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
869 
870         if (uuid == null) {
871             query.append(_FINDER_COLUMN_UUID_UUID_1);
872         }
873         else {
874             if (uuid.equals(StringPool.BLANK)) {
875                 query.append(_FINDER_COLUMN_UUID_UUID_3);
876             }
877             else {
878                 query.append(_FINDER_COLUMN_UUID_UUID_2);
879             }
880         }
881 
882         if (orderByComparator != null) {
883             String[] orderByFields = orderByComparator.getOrderByFields();
884 
885             if (orderByFields.length > 0) {
886                 query.append(WHERE_AND);
887             }
888 
889             for (int i = 0; i < orderByFields.length; i++) {
890                 query.append(_ORDER_BY_ENTITY_ALIAS);
891                 query.append(orderByFields[i]);
892 
893                 if ((i + 1) < orderByFields.length) {
894                     if (orderByComparator.isAscending() ^ previous) {
895                         query.append(WHERE_GREATER_THAN_HAS_NEXT);
896                     }
897                     else {
898                         query.append(WHERE_LESSER_THAN_HAS_NEXT);
899                     }
900                 }
901                 else {
902                     if (orderByComparator.isAscending() ^ previous) {
903                         query.append(WHERE_GREATER_THAN);
904                     }
905                     else {
906                         query.append(WHERE_LESSER_THAN);
907                     }
908                 }
909             }
910 
911             query.append(ORDER_BY_CLAUSE);
912 
913             for (int i = 0; i < orderByFields.length; i++) {
914                 query.append(_ORDER_BY_ENTITY_ALIAS);
915                 query.append(orderByFields[i]);
916 
917                 if ((i + 1) < orderByFields.length) {
918                     if (orderByComparator.isAscending() ^ previous) {
919                         query.append(ORDER_BY_ASC_HAS_NEXT);
920                     }
921                     else {
922                         query.append(ORDER_BY_DESC_HAS_NEXT);
923                     }
924                 }
925                 else {
926                     if (orderByComparator.isAscending() ^ previous) {
927                         query.append(ORDER_BY_ASC);
928                     }
929                     else {
930                         query.append(ORDER_BY_DESC);
931                     }
932                 }
933             }
934         }
935 
936         else {
937             query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
938         }
939 
940         String sql = query.toString();
941 
942         Query q = session.createQuery(sql);
943 
944         q.setFirstResult(0);
945         q.setMaxResults(2);
946 
947         QueryPos qPos = QueryPos.getInstance(q);
948 
949         if (uuid != null) {
950             qPos.add(uuid);
951         }
952 
953         if (orderByComparator != null) {
954             Object[] values = orderByComparator.getOrderByValues(blogsEntry);
955 
956             for (Object value : values) {
957                 qPos.add(value);
958             }
959         }
960 
961         List<BlogsEntry> list = q.list();
962 
963         if (list.size() == 2) {
964             return list.get(1);
965         }
966         else {
967             return null;
968         }
969     }
970 
971     public BlogsEntry findByUUID_G(String uuid, long groupId)
972         throws NoSuchEntryException, SystemException {
973         BlogsEntry blogsEntry = fetchByUUID_G(uuid, groupId);
974 
975         if (blogsEntry == null) {
976             StringBundler msg = new StringBundler(6);
977 
978             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
979 
980             msg.append("uuid=");
981             msg.append(uuid);
982 
983             msg.append(", groupId=");
984             msg.append(groupId);
985 
986             msg.append(StringPool.CLOSE_CURLY_BRACE);
987 
988             if (_log.isWarnEnabled()) {
989                 _log.warn(msg.toString());
990             }
991 
992             throw new NoSuchEntryException(msg.toString());
993         }
994 
995         return blogsEntry;
996     }
997 
998     public BlogsEntry fetchByUUID_G(String uuid, long groupId)
999         throws SystemException {
1000        return fetchByUUID_G(uuid, groupId, true);
1001    }
1002
1003    public BlogsEntry fetchByUUID_G(String uuid, long groupId,
1004        boolean retrieveFromCache) throws SystemException {
1005        Object[] finderArgs = new Object[] { uuid, new Long(groupId) };
1006
1007        Object result = null;
1008
1009        if (retrieveFromCache) {
1010            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_UUID_G,
1011                    finderArgs, this);
1012        }
1013
1014        if (result == null) {
1015            Session session = null;
1016
1017            try {
1018                session = openSession();
1019
1020                StringBundler query = new StringBundler(4);
1021
1022                query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
1023
1024                if (uuid == null) {
1025                    query.append(_FINDER_COLUMN_UUID_G_UUID_1);
1026                }
1027                else {
1028                    if (uuid.equals(StringPool.BLANK)) {
1029                        query.append(_FINDER_COLUMN_UUID_G_UUID_3);
1030                    }
1031                    else {
1032                        query.append(_FINDER_COLUMN_UUID_G_UUID_2);
1033                    }
1034                }
1035
1036                query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
1037
1038                query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
1039
1040                String sql = query.toString();
1041
1042                Query q = session.createQuery(sql);
1043
1044                QueryPos qPos = QueryPos.getInstance(q);
1045
1046                if (uuid != null) {
1047                    qPos.add(uuid);
1048                }
1049
1050                qPos.add(groupId);
1051
1052                List<BlogsEntry> list = q.list();
1053
1054                result = list;
1055
1056                BlogsEntry blogsEntry = null;
1057
1058                if (list.isEmpty()) {
1059                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
1060                        finderArgs, list);
1061                }
1062                else {
1063                    blogsEntry = list.get(0);
1064
1065                    cacheResult(blogsEntry);
1066
1067                    if ((blogsEntry.getUuid() == null) ||
1068                            !blogsEntry.getUuid().equals(uuid) ||
1069                            (blogsEntry.getGroupId() != groupId)) {
1070                        FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
1071                            finderArgs, blogsEntry);
1072                    }
1073                }
1074
1075                return blogsEntry;
1076            }
1077            catch (Exception e) {
1078                throw processException(e);
1079            }
1080            finally {
1081                if (result == null) {
1082                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
1083                        finderArgs, new ArrayList<BlogsEntry>());
1084                }
1085
1086                closeSession(session);
1087            }
1088        }
1089        else {
1090            if (result instanceof List<?>) {
1091                return null;
1092            }
1093            else {
1094                return (BlogsEntry)result;
1095            }
1096        }
1097    }
1098
1099    public List<BlogsEntry> findByGroupId(long groupId)
1100        throws SystemException {
1101        return findByGroupId(groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1102    }
1103
1104    public List<BlogsEntry> findByGroupId(long groupId, int start, int end)
1105        throws SystemException {
1106        return findByGroupId(groupId, start, end, null);
1107    }
1108
1109    public List<BlogsEntry> findByGroupId(long groupId, int start, int end,
1110        OrderByComparator orderByComparator) throws SystemException {
1111        Object[] finderArgs = new Object[] {
1112                new Long(groupId),
1113                
1114                String.valueOf(start), String.valueOf(end),
1115                String.valueOf(orderByComparator)
1116            };
1117
1118        List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_GROUPID,
1119                finderArgs, this);
1120
1121        if (list == null) {
1122            Session session = null;
1123
1124            try {
1125                session = openSession();
1126
1127                StringBundler query = null;
1128
1129                if (orderByComparator != null) {
1130                    query = new StringBundler(3 +
1131                            (orderByComparator.getOrderByFields().length * 3));
1132                }
1133                else {
1134                    query = new StringBundler(3);
1135                }
1136
1137                query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
1138
1139                query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1140
1141                if (orderByComparator != null) {
1142                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1143                        orderByComparator);
1144                }
1145
1146                else {
1147                    query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
1148                }
1149
1150                String sql = query.toString();
1151
1152                Query q = session.createQuery(sql);
1153
1154                QueryPos qPos = QueryPos.getInstance(q);
1155
1156                qPos.add(groupId);
1157
1158                list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start,
1159                        end);
1160            }
1161            catch (Exception e) {
1162                throw processException(e);
1163            }
1164            finally {
1165                if (list == null) {
1166                    list = new ArrayList<BlogsEntry>();
1167                }
1168
1169                cacheResult(list);
1170
1171                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_GROUPID,
1172                    finderArgs, list);
1173
1174                closeSession(session);
1175            }
1176        }
1177
1178        return list;
1179    }
1180
1181    public BlogsEntry findByGroupId_First(long groupId,
1182        OrderByComparator orderByComparator)
1183        throws NoSuchEntryException, SystemException {
1184        List<BlogsEntry> list = findByGroupId(groupId, 0, 1, orderByComparator);
1185
1186        if (list.isEmpty()) {
1187            StringBundler msg = new StringBundler(4);
1188
1189            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1190
1191            msg.append("groupId=");
1192            msg.append(groupId);
1193
1194            msg.append(StringPool.CLOSE_CURLY_BRACE);
1195
1196            throw new NoSuchEntryException(msg.toString());
1197        }
1198        else {
1199            return list.get(0);
1200        }
1201    }
1202
1203    public BlogsEntry findByGroupId_Last(long groupId,
1204        OrderByComparator orderByComparator)
1205        throws NoSuchEntryException, SystemException {
1206        int count = countByGroupId(groupId);
1207
1208        List<BlogsEntry> list = findByGroupId(groupId, count - 1, count,
1209                orderByComparator);
1210
1211        if (list.isEmpty()) {
1212            StringBundler msg = new StringBundler(4);
1213
1214            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1215
1216            msg.append("groupId=");
1217            msg.append(groupId);
1218
1219            msg.append(StringPool.CLOSE_CURLY_BRACE);
1220
1221            throw new NoSuchEntryException(msg.toString());
1222        }
1223        else {
1224            return list.get(0);
1225        }
1226    }
1227
1228    public BlogsEntry[] findByGroupId_PrevAndNext(long entryId, long groupId,
1229        OrderByComparator orderByComparator)
1230        throws NoSuchEntryException, SystemException {
1231        BlogsEntry blogsEntry = findByPrimaryKey(entryId);
1232
1233        Session session = null;
1234
1235        try {
1236            session = openSession();
1237
1238            BlogsEntry[] array = new BlogsEntryImpl[3];
1239
1240            array[0] = getByGroupId_PrevAndNext(session, blogsEntry, groupId,
1241                    orderByComparator, true);
1242
1243            array[1] = blogsEntry;
1244
1245            array[2] = getByGroupId_PrevAndNext(session, blogsEntry, groupId,
1246                    orderByComparator, false);
1247
1248            return array;
1249        }
1250        catch (Exception e) {
1251            throw processException(e);
1252        }
1253        finally {
1254            closeSession(session);
1255        }
1256    }
1257
1258    protected BlogsEntry getByGroupId_PrevAndNext(Session session,
1259        BlogsEntry blogsEntry, long groupId,
1260        OrderByComparator orderByComparator, boolean previous) {
1261        StringBundler query = null;
1262
1263        if (orderByComparator != null) {
1264            query = new StringBundler(6 +
1265                    (orderByComparator.getOrderByFields().length * 6));
1266        }
1267        else {
1268            query = new StringBundler(3);
1269        }
1270
1271        query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
1272
1273        query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1274
1275        if (orderByComparator != null) {
1276            String[] orderByFields = orderByComparator.getOrderByFields();
1277
1278            if (orderByFields.length > 0) {
1279                query.append(WHERE_AND);
1280            }
1281
1282            for (int i = 0; i < orderByFields.length; i++) {
1283                query.append(_ORDER_BY_ENTITY_ALIAS);
1284                query.append(orderByFields[i]);
1285
1286                if ((i + 1) < orderByFields.length) {
1287                    if (orderByComparator.isAscending() ^ previous) {
1288                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
1289                    }
1290                    else {
1291                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
1292                    }
1293                }
1294                else {
1295                    if (orderByComparator.isAscending() ^ previous) {
1296                        query.append(WHERE_GREATER_THAN);
1297                    }
1298                    else {
1299                        query.append(WHERE_LESSER_THAN);
1300                    }
1301                }
1302            }
1303
1304            query.append(ORDER_BY_CLAUSE);
1305
1306            for (int i = 0; i < orderByFields.length; i++) {
1307                query.append(_ORDER_BY_ENTITY_ALIAS);
1308                query.append(orderByFields[i]);
1309
1310                if ((i + 1) < orderByFields.length) {
1311                    if (orderByComparator.isAscending() ^ previous) {
1312                        query.append(ORDER_BY_ASC_HAS_NEXT);
1313                    }
1314                    else {
1315                        query.append(ORDER_BY_DESC_HAS_NEXT);
1316                    }
1317                }
1318                else {
1319                    if (orderByComparator.isAscending() ^ previous) {
1320                        query.append(ORDER_BY_ASC);
1321                    }
1322                    else {
1323                        query.append(ORDER_BY_DESC);
1324                    }
1325                }
1326            }
1327        }
1328
1329        else {
1330            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
1331        }
1332
1333        String sql = query.toString();
1334
1335        Query q = session.createQuery(sql);
1336
1337        q.setFirstResult(0);
1338        q.setMaxResults(2);
1339
1340        QueryPos qPos = QueryPos.getInstance(q);
1341
1342        qPos.add(groupId);
1343
1344        if (orderByComparator != null) {
1345            Object[] values = orderByComparator.getOrderByValues(blogsEntry);
1346
1347            for (Object value : values) {
1348                qPos.add(value);
1349            }
1350        }
1351
1352        List<BlogsEntry> list = q.list();
1353
1354        if (list.size() == 2) {
1355            return list.get(1);
1356        }
1357        else {
1358            return null;
1359        }
1360    }
1361
1362    public List<BlogsEntry> filterFindByGroupId(long groupId)
1363        throws SystemException {
1364        return filterFindByGroupId(groupId, QueryUtil.ALL_POS,
1365            QueryUtil.ALL_POS, null);
1366    }
1367
1368    public List<BlogsEntry> filterFindByGroupId(long groupId, int start, int end)
1369        throws SystemException {
1370        return filterFindByGroupId(groupId, start, end, null);
1371    }
1372
1373    public List<BlogsEntry> filterFindByGroupId(long groupId, int start,
1374        int end, OrderByComparator orderByComparator) throws SystemException {
1375        if (!InlineSQLHelperUtil.isEnabled(groupId)) {
1376            return findByGroupId(groupId, start, end, orderByComparator);
1377        }
1378
1379        Session session = null;
1380
1381        try {
1382            session = openSession();
1383
1384            StringBundler query = null;
1385
1386            if (orderByComparator != null) {
1387                query = new StringBundler(3 +
1388                        (orderByComparator.getOrderByFields().length * 3));
1389            }
1390            else {
1391                query = new StringBundler(3);
1392            }
1393
1394            query.append(_FILTER_SQL_SELECT_BLOGSENTRY_WHERE);
1395
1396            query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1397
1398            if (orderByComparator != null) {
1399                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1400                    orderByComparator);
1401            }
1402
1403            else {
1404                query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
1405            }
1406
1407            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
1408                    BlogsEntry.class.getName(), _FILTER_COLUMN_ENTRYID,
1409                    _FILTER_COLUMN_USERID, groupId);
1410
1411            SQLQuery q = session.createSQLQuery(sql);
1412
1413            q.addEntity(_FILTER_ENTITY_ALIAS, BlogsEntryImpl.class);
1414
1415            QueryPos qPos = QueryPos.getInstance(q);
1416
1417            qPos.add(groupId);
1418
1419            return (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start, end);
1420        }
1421        catch (Exception e) {
1422            throw processException(e);
1423        }
1424        finally {
1425            closeSession(session);
1426        }
1427    }
1428
1429    public List<BlogsEntry> findByCompanyId(long companyId)
1430        throws SystemException {
1431        return findByCompanyId(companyId, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
1432            null);
1433    }
1434
1435    public List<BlogsEntry> findByCompanyId(long companyId, int start, int end)
1436        throws SystemException {
1437        return findByCompanyId(companyId, start, end, null);
1438    }
1439
1440    public List<BlogsEntry> findByCompanyId(long companyId, int start, int end,
1441        OrderByComparator orderByComparator) throws SystemException {
1442        Object[] finderArgs = new Object[] {
1443                new Long(companyId),
1444                
1445                String.valueOf(start), String.valueOf(end),
1446                String.valueOf(orderByComparator)
1447            };
1448
1449        List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_COMPANYID,
1450                finderArgs, this);
1451
1452        if (list == null) {
1453            Session session = null;
1454
1455            try {
1456                session = openSession();
1457
1458                StringBundler query = null;
1459
1460                if (orderByComparator != null) {
1461                    query = new StringBundler(3 +
1462                            (orderByComparator.getOrderByFields().length * 3));
1463                }
1464                else {
1465                    query = new StringBundler(3);
1466                }
1467
1468                query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
1469
1470                query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
1471
1472                if (orderByComparator != null) {
1473                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1474                        orderByComparator);
1475                }
1476
1477                else {
1478                    query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
1479                }
1480
1481                String sql = query.toString();
1482
1483                Query q = session.createQuery(sql);
1484
1485                QueryPos qPos = QueryPos.getInstance(q);
1486
1487                qPos.add(companyId);
1488
1489                list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start,
1490                        end);
1491            }
1492            catch (Exception e) {
1493                throw processException(e);
1494            }
1495            finally {
1496                if (list == null) {
1497                    list = new ArrayList<BlogsEntry>();
1498                }
1499
1500                cacheResult(list);
1501
1502                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_COMPANYID,
1503                    finderArgs, list);
1504
1505                closeSession(session);
1506            }
1507        }
1508
1509        return list;
1510    }
1511
1512    public BlogsEntry findByCompanyId_First(long companyId,
1513        OrderByComparator orderByComparator)
1514        throws NoSuchEntryException, SystemException {
1515        List<BlogsEntry> list = findByCompanyId(companyId, 0, 1,
1516                orderByComparator);
1517
1518        if (list.isEmpty()) {
1519            StringBundler msg = new StringBundler(4);
1520
1521            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1522
1523            msg.append("companyId=");
1524            msg.append(companyId);
1525
1526            msg.append(StringPool.CLOSE_CURLY_BRACE);
1527
1528            throw new NoSuchEntryException(msg.toString());
1529        }
1530        else {
1531            return list.get(0);
1532        }
1533    }
1534
1535    public BlogsEntry findByCompanyId_Last(long companyId,
1536        OrderByComparator orderByComparator)
1537        throws NoSuchEntryException, SystemException {
1538        int count = countByCompanyId(companyId);
1539
1540        List<BlogsEntry> list = findByCompanyId(companyId, count - 1, count,
1541                orderByComparator);
1542
1543        if (list.isEmpty()) {
1544            StringBundler msg = new StringBundler(4);
1545
1546            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1547
1548            msg.append("companyId=");
1549            msg.append(companyId);
1550
1551            msg.append(StringPool.CLOSE_CURLY_BRACE);
1552
1553            throw new NoSuchEntryException(msg.toString());
1554        }
1555        else {
1556            return list.get(0);
1557        }
1558    }
1559
1560    public BlogsEntry[] findByCompanyId_PrevAndNext(long entryId,
1561        long companyId, OrderByComparator orderByComparator)
1562        throws NoSuchEntryException, SystemException {
1563        BlogsEntry blogsEntry = findByPrimaryKey(entryId);
1564
1565        Session session = null;
1566
1567        try {
1568            session = openSession();
1569
1570            BlogsEntry[] array = new BlogsEntryImpl[3];
1571
1572            array[0] = getByCompanyId_PrevAndNext(session, blogsEntry,
1573                    companyId, orderByComparator, true);
1574
1575            array[1] = blogsEntry;
1576
1577            array[2] = getByCompanyId_PrevAndNext(session, blogsEntry,
1578                    companyId, orderByComparator, false);
1579
1580            return array;
1581        }
1582        catch (Exception e) {
1583            throw processException(e);
1584        }
1585        finally {
1586            closeSession(session);
1587        }
1588    }
1589
1590    protected BlogsEntry getByCompanyId_PrevAndNext(Session session,
1591        BlogsEntry blogsEntry, long companyId,
1592        OrderByComparator orderByComparator, boolean previous) {
1593        StringBundler query = null;
1594
1595        if (orderByComparator != null) {
1596            query = new StringBundler(6 +
1597                    (orderByComparator.getOrderByFields().length * 6));
1598        }
1599        else {
1600            query = new StringBundler(3);
1601        }
1602
1603        query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
1604
1605        query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
1606
1607        if (orderByComparator != null) {
1608            String[] orderByFields = orderByComparator.getOrderByFields();
1609
1610            if (orderByFields.length > 0) {
1611                query.append(WHERE_AND);
1612            }
1613
1614            for (int i = 0; i < orderByFields.length; i++) {
1615                query.append(_ORDER_BY_ENTITY_ALIAS);
1616                query.append(orderByFields[i]);
1617
1618                if ((i + 1) < orderByFields.length) {
1619                    if (orderByComparator.isAscending() ^ previous) {
1620                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
1621                    }
1622                    else {
1623                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
1624                    }
1625                }
1626                else {
1627                    if (orderByComparator.isAscending() ^ previous) {
1628                        query.append(WHERE_GREATER_THAN);
1629                    }
1630                    else {
1631                        query.append(WHERE_LESSER_THAN);
1632                    }
1633                }
1634            }
1635
1636            query.append(ORDER_BY_CLAUSE);
1637
1638            for (int i = 0; i < orderByFields.length; i++) {
1639                query.append(_ORDER_BY_ENTITY_ALIAS);
1640                query.append(orderByFields[i]);
1641
1642                if ((i + 1) < orderByFields.length) {
1643                    if (orderByComparator.isAscending() ^ previous) {
1644                        query.append(ORDER_BY_ASC_HAS_NEXT);
1645                    }
1646                    else {
1647                        query.append(ORDER_BY_DESC_HAS_NEXT);
1648                    }
1649                }
1650                else {
1651                    if (orderByComparator.isAscending() ^ previous) {
1652                        query.append(ORDER_BY_ASC);
1653                    }
1654                    else {
1655                        query.append(ORDER_BY_DESC);
1656                    }
1657                }
1658            }
1659        }
1660
1661        else {
1662            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
1663        }
1664
1665        String sql = query.toString();
1666
1667        Query q = session.createQuery(sql);
1668
1669        q.setFirstResult(0);
1670        q.setMaxResults(2);
1671
1672        QueryPos qPos = QueryPos.getInstance(q);
1673
1674        qPos.add(companyId);
1675
1676        if (orderByComparator != null) {
1677            Object[] values = orderByComparator.getOrderByValues(blogsEntry);
1678
1679            for (Object value : values) {
1680                qPos.add(value);
1681            }
1682        }
1683
1684        List<BlogsEntry> list = q.list();
1685
1686        if (list.size() == 2) {
1687            return list.get(1);
1688        }
1689        else {
1690            return null;
1691        }
1692    }
1693
1694    public List<BlogsEntry> findByC_U(long companyId, long userId)
1695        throws SystemException {
1696        return findByC_U(companyId, userId, QueryUtil.ALL_POS,
1697            QueryUtil.ALL_POS, null);
1698    }
1699
1700    public List<BlogsEntry> findByC_U(long companyId, long userId, int start,
1701        int end) throws SystemException {
1702        return findByC_U(companyId, userId, start, end, null);
1703    }
1704
1705    public List<BlogsEntry> findByC_U(long companyId, long userId, int start,
1706        int end, OrderByComparator orderByComparator) throws SystemException {
1707        Object[] finderArgs = new Object[] {
1708                new Long(companyId), new Long(userId),
1709                
1710                String.valueOf(start), String.valueOf(end),
1711                String.valueOf(orderByComparator)
1712            };
1713
1714        List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_C_U,
1715                finderArgs, this);
1716
1717        if (list == null) {
1718            Session session = null;
1719
1720            try {
1721                session = openSession();
1722
1723                StringBundler query = null;
1724
1725                if (orderByComparator != null) {
1726                    query = new StringBundler(4 +
1727                            (orderByComparator.getOrderByFields().length * 3));
1728                }
1729                else {
1730                    query = new StringBundler(4);
1731                }
1732
1733                query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
1734
1735                query.append(_FINDER_COLUMN_C_U_COMPANYID_2);
1736
1737                query.append(_FINDER_COLUMN_C_U_USERID_2);
1738
1739                if (orderByComparator != null) {
1740                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1741                        orderByComparator);
1742                }
1743
1744                else {
1745                    query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
1746                }
1747
1748                String sql = query.toString();
1749
1750                Query q = session.createQuery(sql);
1751
1752                QueryPos qPos = QueryPos.getInstance(q);
1753
1754                qPos.add(companyId);
1755
1756                qPos.add(userId);
1757
1758                list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start,
1759                        end);
1760            }
1761            catch (Exception e) {
1762                throw processException(e);
1763            }
1764            finally {
1765                if (list == null) {
1766                    list = new ArrayList<BlogsEntry>();
1767                }
1768
1769                cacheResult(list);
1770
1771                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_C_U, finderArgs,
1772                    list);
1773
1774                closeSession(session);
1775            }
1776        }
1777
1778        return list;
1779    }
1780
1781    public BlogsEntry findByC_U_First(long companyId, long userId,
1782        OrderByComparator orderByComparator)
1783        throws NoSuchEntryException, SystemException {
1784        List<BlogsEntry> list = findByC_U(companyId, userId, 0, 1,
1785                orderByComparator);
1786
1787        if (list.isEmpty()) {
1788            StringBundler msg = new StringBundler(6);
1789
1790            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1791
1792            msg.append("companyId=");
1793            msg.append(companyId);
1794
1795            msg.append(", userId=");
1796            msg.append(userId);
1797
1798            msg.append(StringPool.CLOSE_CURLY_BRACE);
1799
1800            throw new NoSuchEntryException(msg.toString());
1801        }
1802        else {
1803            return list.get(0);
1804        }
1805    }
1806
1807    public BlogsEntry findByC_U_Last(long companyId, long userId,
1808        OrderByComparator orderByComparator)
1809        throws NoSuchEntryException, SystemException {
1810        int count = countByC_U(companyId, userId);
1811
1812        List<BlogsEntry> list = findByC_U(companyId, userId, count - 1, count,
1813                orderByComparator);
1814
1815        if (list.isEmpty()) {
1816            StringBundler msg = new StringBundler(6);
1817
1818            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1819
1820            msg.append("companyId=");
1821            msg.append(companyId);
1822
1823            msg.append(", userId=");
1824            msg.append(userId);
1825
1826            msg.append(StringPool.CLOSE_CURLY_BRACE);
1827
1828            throw new NoSuchEntryException(msg.toString());
1829        }
1830        else {
1831            return list.get(0);
1832        }
1833    }
1834
1835    public BlogsEntry[] findByC_U_PrevAndNext(long entryId, long companyId,
1836        long userId, OrderByComparator orderByComparator)
1837        throws NoSuchEntryException, SystemException {
1838        BlogsEntry blogsEntry = findByPrimaryKey(entryId);
1839
1840        Session session = null;
1841
1842        try {
1843            session = openSession();
1844
1845            BlogsEntry[] array = new BlogsEntryImpl[3];
1846
1847            array[0] = getByC_U_PrevAndNext(session, blogsEntry, companyId,
1848                    userId, orderByComparator, true);
1849
1850            array[1] = blogsEntry;
1851
1852            array[2] = getByC_U_PrevAndNext(session, blogsEntry, companyId,
1853                    userId, orderByComparator, false);
1854
1855            return array;
1856        }
1857        catch (Exception e) {
1858            throw processException(e);
1859        }
1860        finally {
1861            closeSession(session);
1862        }
1863    }
1864
1865    protected BlogsEntry getByC_U_PrevAndNext(Session session,
1866        BlogsEntry blogsEntry, long companyId, long userId,
1867        OrderByComparator orderByComparator, boolean previous) {
1868        StringBundler query = null;
1869
1870        if (orderByComparator != null) {
1871            query = new StringBundler(6 +
1872                    (orderByComparator.getOrderByFields().length * 6));
1873        }
1874        else {
1875            query = new StringBundler(3);
1876        }
1877
1878        query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
1879
1880        query.append(_FINDER_COLUMN_C_U_COMPANYID_2);
1881
1882        query.append(_FINDER_COLUMN_C_U_USERID_2);
1883
1884        if (orderByComparator != null) {
1885            String[] orderByFields = orderByComparator.getOrderByFields();
1886
1887            if (orderByFields.length > 0) {
1888                query.append(WHERE_AND);
1889            }
1890
1891            for (int i = 0; i < orderByFields.length; i++) {
1892                query.append(_ORDER_BY_ENTITY_ALIAS);
1893                query.append(orderByFields[i]);
1894
1895                if ((i + 1) < orderByFields.length) {
1896                    if (orderByComparator.isAscending() ^ previous) {
1897                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
1898                    }
1899                    else {
1900                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
1901                    }
1902                }
1903                else {
1904                    if (orderByComparator.isAscending() ^ previous) {
1905                        query.append(WHERE_GREATER_THAN);
1906                    }
1907                    else {
1908                        query.append(WHERE_LESSER_THAN);
1909                    }
1910                }
1911            }
1912
1913            query.append(ORDER_BY_CLAUSE);
1914
1915            for (int i = 0; i < orderByFields.length; i++) {
1916                query.append(_ORDER_BY_ENTITY_ALIAS);
1917                query.append(orderByFields[i]);
1918
1919                if ((i + 1) < orderByFields.length) {
1920                    if (orderByComparator.isAscending() ^ previous) {
1921                        query.append(ORDER_BY_ASC_HAS_NEXT);
1922                    }
1923                    else {
1924                        query.append(ORDER_BY_DESC_HAS_NEXT);
1925                    }
1926                }
1927                else {
1928                    if (orderByComparator.isAscending() ^ previous) {
1929                        query.append(ORDER_BY_ASC);
1930                    }
1931                    else {
1932                        query.append(ORDER_BY_DESC);
1933                    }
1934                }
1935            }
1936        }
1937
1938        else {
1939            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
1940        }
1941
1942        String sql = query.toString();
1943
1944        Query q = session.createQuery(sql);
1945
1946        q.setFirstResult(0);
1947        q.setMaxResults(2);
1948
1949        QueryPos qPos = QueryPos.getInstance(q);
1950
1951        qPos.add(companyId);
1952
1953        qPos.add(userId);
1954
1955        if (orderByComparator != null) {
1956            Object[] values = orderByComparator.getOrderByValues(blogsEntry);
1957
1958            for (Object value : values) {
1959                qPos.add(value);
1960            }
1961        }
1962
1963        List<BlogsEntry> list = q.list();
1964
1965        if (list.size() == 2) {
1966            return list.get(1);
1967        }
1968        else {
1969            return null;
1970        }
1971    }
1972
1973    public List<BlogsEntry> findByC_D(long companyId, Date displayDate)
1974        throws SystemException {
1975        return findByC_D(companyId, displayDate, QueryUtil.ALL_POS,
1976            QueryUtil.ALL_POS, null);
1977    }
1978
1979    public List<BlogsEntry> findByC_D(long companyId, Date displayDate,
1980        int start, int end) throws SystemException {
1981        return findByC_D(companyId, displayDate, start, end, null);
1982    }
1983
1984    public List<BlogsEntry> findByC_D(long companyId, Date displayDate,
1985        int start, int end, OrderByComparator orderByComparator)
1986        throws SystemException {
1987        Object[] finderArgs = new Object[] {
1988                new Long(companyId),
1989                
1990                displayDate,
1991                
1992                String.valueOf(start), String.valueOf(end),
1993                String.valueOf(orderByComparator)
1994            };
1995
1996        List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_C_D,
1997                finderArgs, this);
1998
1999        if (list == null) {
2000            Session session = null;
2001
2002            try {
2003                session = openSession();
2004
2005                StringBundler query = null;
2006
2007                if (orderByComparator != null) {
2008                    query = new StringBundler(4 +
2009                            (orderByComparator.getOrderByFields().length * 3));
2010                }
2011                else {
2012                    query = new StringBundler(4);
2013                }
2014
2015                query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
2016
2017                query.append(_FINDER_COLUMN_C_D_COMPANYID_2);
2018
2019                if (displayDate == null) {
2020                    query.append(_FINDER_COLUMN_C_D_DISPLAYDATE_1);
2021                }
2022                else {
2023                    query.append(_FINDER_COLUMN_C_D_DISPLAYDATE_2);
2024                }
2025
2026                if (orderByComparator != null) {
2027                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2028                        orderByComparator);
2029                }
2030
2031                else {
2032                    query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
2033                }
2034
2035                String sql = query.toString();
2036
2037                Query q = session.createQuery(sql);
2038
2039                QueryPos qPos = QueryPos.getInstance(q);
2040
2041                qPos.add(companyId);
2042
2043                if (displayDate != null) {
2044                    qPos.add(CalendarUtil.getTimestamp(displayDate));
2045                }
2046
2047                list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start,
2048                        end);
2049            }
2050            catch (Exception e) {
2051                throw processException(e);
2052            }
2053            finally {
2054                if (list == null) {
2055                    list = new ArrayList<BlogsEntry>();
2056                }
2057
2058                cacheResult(list);
2059
2060                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_C_D, finderArgs,
2061                    list);
2062
2063                closeSession(session);
2064            }
2065        }
2066
2067        return list;
2068    }
2069
2070    public BlogsEntry findByC_D_First(long companyId, Date displayDate,
2071        OrderByComparator orderByComparator)
2072        throws NoSuchEntryException, SystemException {
2073        List<BlogsEntry> list = findByC_D(companyId, displayDate, 0, 1,
2074                orderByComparator);
2075
2076        if (list.isEmpty()) {
2077            StringBundler msg = new StringBundler(6);
2078
2079            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2080
2081            msg.append("companyId=");
2082            msg.append(companyId);
2083
2084            msg.append(", displayDate=");
2085            msg.append(displayDate);
2086
2087            msg.append(StringPool.CLOSE_CURLY_BRACE);
2088
2089            throw new NoSuchEntryException(msg.toString());
2090        }
2091        else {
2092            return list.get(0);
2093        }
2094    }
2095
2096    public BlogsEntry findByC_D_Last(long companyId, Date displayDate,
2097        OrderByComparator orderByComparator)
2098        throws NoSuchEntryException, SystemException {
2099        int count = countByC_D(companyId, displayDate);
2100
2101        List<BlogsEntry> list = findByC_D(companyId, displayDate, count - 1,
2102                count, orderByComparator);
2103
2104        if (list.isEmpty()) {
2105            StringBundler msg = new StringBundler(6);
2106
2107            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2108
2109            msg.append("companyId=");
2110            msg.append(companyId);
2111
2112            msg.append(", displayDate=");
2113            msg.append(displayDate);
2114
2115            msg.append(StringPool.CLOSE_CURLY_BRACE);
2116
2117            throw new NoSuchEntryException(msg.toString());
2118        }
2119        else {
2120            return list.get(0);
2121        }
2122    }
2123
2124    public BlogsEntry[] findByC_D_PrevAndNext(long entryId, long companyId,
2125        Date displayDate, OrderByComparator orderByComparator)
2126        throws NoSuchEntryException, SystemException {
2127        BlogsEntry blogsEntry = findByPrimaryKey(entryId);
2128
2129        Session session = null;
2130
2131        try {
2132            session = openSession();
2133
2134            BlogsEntry[] array = new BlogsEntryImpl[3];
2135
2136            array[0] = getByC_D_PrevAndNext(session, blogsEntry, companyId,
2137                    displayDate, orderByComparator, true);
2138
2139            array[1] = blogsEntry;
2140
2141            array[2] = getByC_D_PrevAndNext(session, blogsEntry, companyId,
2142                    displayDate, orderByComparator, false);
2143
2144            return array;
2145        }
2146        catch (Exception e) {
2147            throw processException(e);
2148        }
2149        finally {
2150            closeSession(session);
2151        }
2152    }
2153
2154    protected BlogsEntry getByC_D_PrevAndNext(Session session,
2155        BlogsEntry blogsEntry, long companyId, Date displayDate,
2156        OrderByComparator orderByComparator, boolean previous) {
2157        StringBundler query = null;
2158
2159        if (orderByComparator != null) {
2160            query = new StringBundler(6 +
2161                    (orderByComparator.getOrderByFields().length * 6));
2162        }
2163        else {
2164            query = new StringBundler(3);
2165        }
2166
2167        query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
2168
2169        query.append(_FINDER_COLUMN_C_D_COMPANYID_2);
2170
2171        if (displayDate == null) {
2172            query.append(_FINDER_COLUMN_C_D_DISPLAYDATE_1);
2173        }
2174        else {
2175            query.append(_FINDER_COLUMN_C_D_DISPLAYDATE_2);
2176        }
2177
2178        if (orderByComparator != null) {
2179            String[] orderByFields = orderByComparator.getOrderByFields();
2180
2181            if (orderByFields.length > 0) {
2182                query.append(WHERE_AND);
2183            }
2184
2185            for (int i = 0; i < orderByFields.length; i++) {
2186                query.append(_ORDER_BY_ENTITY_ALIAS);
2187                query.append(orderByFields[i]);
2188
2189                if ((i + 1) < orderByFields.length) {
2190                    if (orderByComparator.isAscending() ^ previous) {
2191                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
2192                    }
2193                    else {
2194                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
2195                    }
2196                }
2197                else {
2198                    if (orderByComparator.isAscending() ^ previous) {
2199                        query.append(WHERE_GREATER_THAN);
2200                    }
2201                    else {
2202                        query.append(WHERE_LESSER_THAN);
2203                    }
2204                }
2205            }
2206
2207            query.append(ORDER_BY_CLAUSE);
2208
2209            for (int i = 0; i < orderByFields.length; i++) {
2210                query.append(_ORDER_BY_ENTITY_ALIAS);
2211                query.append(orderByFields[i]);
2212
2213                if ((i + 1) < orderByFields.length) {
2214                    if (orderByComparator.isAscending() ^ previous) {
2215                        query.append(ORDER_BY_ASC_HAS_NEXT);
2216                    }
2217                    else {
2218                        query.append(ORDER_BY_DESC_HAS_NEXT);
2219                    }
2220                }
2221                else {
2222                    if (orderByComparator.isAscending() ^ previous) {
2223                        query.append(ORDER_BY_ASC);
2224                    }
2225                    else {
2226                        query.append(ORDER_BY_DESC);
2227                    }
2228                }
2229            }
2230        }
2231
2232        else {
2233            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
2234        }
2235
2236        String sql = query.toString();
2237
2238        Query q = session.createQuery(sql);
2239
2240        q.setFirstResult(0);
2241        q.setMaxResults(2);
2242
2243        QueryPos qPos = QueryPos.getInstance(q);
2244
2245        qPos.add(companyId);
2246
2247        if (displayDate != null) {
2248            qPos.add(CalendarUtil.getTimestamp(displayDate));
2249        }
2250
2251        if (orderByComparator != null) {
2252            Object[] values = orderByComparator.getOrderByValues(blogsEntry);
2253
2254            for (Object value : values) {
2255                qPos.add(value);
2256            }
2257        }
2258
2259        List<BlogsEntry> list = q.list();
2260
2261        if (list.size() == 2) {
2262            return list.get(1);
2263        }
2264        else {
2265            return null;
2266        }
2267    }
2268
2269    public List<BlogsEntry> findByC_S(long companyId, int status)
2270        throws SystemException {
2271        return findByC_S(companyId, status, QueryUtil.ALL_POS,
2272            QueryUtil.ALL_POS, null);
2273    }
2274
2275    public List<BlogsEntry> findByC_S(long companyId, int status, int start,
2276        int end) throws SystemException {
2277        return findByC_S(companyId, status, start, end, null);
2278    }
2279
2280    public List<BlogsEntry> findByC_S(long companyId, int status, int start,
2281        int end, OrderByComparator orderByComparator) throws SystemException {
2282        Object[] finderArgs = new Object[] {
2283                new Long(companyId), new Integer(status),
2284                
2285                String.valueOf(start), String.valueOf(end),
2286                String.valueOf(orderByComparator)
2287            };
2288
2289        List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_C_S,
2290                finderArgs, this);
2291
2292        if (list == null) {
2293            Session session = null;
2294
2295            try {
2296                session = openSession();
2297
2298                StringBundler query = null;
2299
2300                if (orderByComparator != null) {
2301                    query = new StringBundler(4 +
2302                            (orderByComparator.getOrderByFields().length * 3));
2303                }
2304                else {
2305                    query = new StringBundler(4);
2306                }
2307
2308                query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
2309
2310                query.append(_FINDER_COLUMN_C_S_COMPANYID_2);
2311
2312                query.append(_FINDER_COLUMN_C_S_STATUS_2);
2313
2314                if (orderByComparator != null) {
2315                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2316                        orderByComparator);
2317                }
2318
2319                else {
2320                    query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
2321                }
2322
2323                String sql = query.toString();
2324
2325                Query q = session.createQuery(sql);
2326
2327                QueryPos qPos = QueryPos.getInstance(q);
2328
2329                qPos.add(companyId);
2330
2331                qPos.add(status);
2332
2333                list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start,
2334                        end);
2335            }
2336            catch (Exception e) {
2337                throw processException(e);
2338            }
2339            finally {
2340                if (list == null) {
2341                    list = new ArrayList<BlogsEntry>();
2342                }
2343
2344                cacheResult(list);
2345
2346                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_C_S, finderArgs,
2347                    list);
2348
2349                closeSession(session);
2350            }
2351        }
2352
2353        return list;
2354    }
2355
2356    public BlogsEntry findByC_S_First(long companyId, int status,
2357        OrderByComparator orderByComparator)
2358        throws NoSuchEntryException, SystemException {
2359        List<BlogsEntry> list = findByC_S(companyId, status, 0, 1,
2360                orderByComparator);
2361
2362        if (list.isEmpty()) {
2363            StringBundler msg = new StringBundler(6);
2364
2365            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2366
2367            msg.append("companyId=");
2368            msg.append(companyId);
2369
2370            msg.append(", status=");
2371            msg.append(status);
2372
2373            msg.append(StringPool.CLOSE_CURLY_BRACE);
2374
2375            throw new NoSuchEntryException(msg.toString());
2376        }
2377        else {
2378            return list.get(0);
2379        }
2380    }
2381
2382    public BlogsEntry findByC_S_Last(long companyId, int status,
2383        OrderByComparator orderByComparator)
2384        throws NoSuchEntryException, SystemException {
2385        int count = countByC_S(companyId, status);
2386
2387        List<BlogsEntry> list = findByC_S(companyId, status, count - 1, count,
2388                orderByComparator);
2389
2390        if (list.isEmpty()) {
2391            StringBundler msg = new StringBundler(6);
2392
2393            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2394
2395            msg.append("companyId=");
2396            msg.append(companyId);
2397
2398            msg.append(", status=");
2399            msg.append(status);
2400
2401            msg.append(StringPool.CLOSE_CURLY_BRACE);
2402
2403            throw new NoSuchEntryException(msg.toString());
2404        }
2405        else {
2406            return list.get(0);
2407        }
2408    }
2409
2410    public BlogsEntry[] findByC_S_PrevAndNext(long entryId, long companyId,
2411        int status, OrderByComparator orderByComparator)
2412        throws NoSuchEntryException, SystemException {
2413        BlogsEntry blogsEntry = findByPrimaryKey(entryId);
2414
2415        Session session = null;
2416
2417        try {
2418            session = openSession();
2419
2420            BlogsEntry[] array = new BlogsEntryImpl[3];
2421
2422            array[0] = getByC_S_PrevAndNext(session, blogsEntry, companyId,
2423                    status, orderByComparator, true);
2424
2425            array[1] = blogsEntry;
2426
2427            array[2] = getByC_S_PrevAndNext(session, blogsEntry, companyId,
2428                    status, orderByComparator, false);
2429
2430            return array;
2431        }
2432        catch (Exception e) {
2433            throw processException(e);
2434        }
2435        finally {
2436            closeSession(session);
2437        }
2438    }
2439
2440    protected BlogsEntry getByC_S_PrevAndNext(Session session,
2441        BlogsEntry blogsEntry, long companyId, int status,
2442        OrderByComparator orderByComparator, boolean previous) {
2443        StringBundler query = null;
2444
2445        if (orderByComparator != null) {
2446            query = new StringBundler(6 +
2447                    (orderByComparator.getOrderByFields().length * 6));
2448        }
2449        else {
2450            query = new StringBundler(3);
2451        }
2452
2453        query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
2454
2455        query.append(_FINDER_COLUMN_C_S_COMPANYID_2);
2456
2457        query.append(_FINDER_COLUMN_C_S_STATUS_2);
2458
2459        if (orderByComparator != null) {
2460            String[] orderByFields = orderByComparator.getOrderByFields();
2461
2462            if (orderByFields.length > 0) {
2463                query.append(WHERE_AND);
2464            }
2465
2466            for (int i = 0; i < orderByFields.length; i++) {
2467                query.append(_ORDER_BY_ENTITY_ALIAS);
2468                query.append(orderByFields[i]);
2469
2470                if ((i + 1) < orderByFields.length) {
2471                    if (orderByComparator.isAscending() ^ previous) {
2472                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
2473                    }
2474                    else {
2475                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
2476                    }
2477                }
2478                else {
2479                    if (orderByComparator.isAscending() ^ previous) {
2480                        query.append(WHERE_GREATER_THAN);
2481                    }
2482                    else {
2483                        query.append(WHERE_LESSER_THAN);
2484                    }
2485                }
2486            }
2487
2488            query.append(ORDER_BY_CLAUSE);
2489
2490            for (int i = 0; i < orderByFields.length; i++) {
2491                query.append(_ORDER_BY_ENTITY_ALIAS);
2492                query.append(orderByFields[i]);
2493
2494                if ((i + 1) < orderByFields.length) {
2495                    if (orderByComparator.isAscending() ^ previous) {
2496                        query.append(ORDER_BY_ASC_HAS_NEXT);
2497                    }
2498                    else {
2499                        query.append(ORDER_BY_DESC_HAS_NEXT);
2500                    }
2501                }
2502                else {
2503                    if (orderByComparator.isAscending() ^ previous) {
2504                        query.append(ORDER_BY_ASC);
2505                    }
2506                    else {
2507                        query.append(ORDER_BY_DESC);
2508                    }
2509                }
2510            }
2511        }
2512
2513        else {
2514            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
2515        }
2516
2517        String sql = query.toString();
2518
2519        Query q = session.createQuery(sql);
2520
2521        q.setFirstResult(0);
2522        q.setMaxResults(2);
2523
2524        QueryPos qPos = QueryPos.getInstance(q);
2525
2526        qPos.add(companyId);
2527
2528        qPos.add(status);
2529
2530        if (orderByComparator != null) {
2531            Object[] values = orderByComparator.getOrderByValues(blogsEntry);
2532
2533            for (Object value : values) {
2534                qPos.add(value);
2535            }
2536        }
2537
2538        List<BlogsEntry> list = q.list();
2539
2540        if (list.size() == 2) {
2541            return list.get(1);
2542        }
2543        else {
2544            return null;
2545        }
2546    }
2547
2548    public BlogsEntry findByG_UT(long groupId, String urlTitle)
2549        throws NoSuchEntryException, SystemException {
2550        BlogsEntry blogsEntry = fetchByG_UT(groupId, urlTitle);
2551
2552        if (blogsEntry == null) {
2553            StringBundler msg = new StringBundler(6);
2554
2555            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2556
2557            msg.append("groupId=");
2558            msg.append(groupId);
2559
2560            msg.append(", urlTitle=");
2561            msg.append(urlTitle);
2562
2563            msg.append(StringPool.CLOSE_CURLY_BRACE);
2564
2565            if (_log.isWarnEnabled()) {
2566                _log.warn(msg.toString());
2567            }
2568
2569            throw new NoSuchEntryException(msg.toString());
2570        }
2571
2572        return blogsEntry;
2573    }
2574
2575    public BlogsEntry fetchByG_UT(long groupId, String urlTitle)
2576        throws SystemException {
2577        return fetchByG_UT(groupId, urlTitle, true);
2578    }
2579
2580    public BlogsEntry fetchByG_UT(long groupId, String urlTitle,
2581        boolean retrieveFromCache) throws SystemException {
2582        Object[] finderArgs = new Object[] { new Long(groupId), urlTitle };
2583
2584        Object result = null;
2585
2586        if (retrieveFromCache) {
2587            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_G_UT,
2588                    finderArgs, this);
2589        }
2590
2591        if (result == null) {
2592            Session session = null;
2593
2594            try {
2595                session = openSession();
2596
2597                StringBundler query = new StringBundler(4);
2598
2599                query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
2600
2601                query.append(_FINDER_COLUMN_G_UT_GROUPID_2);
2602
2603                if (urlTitle == null) {
2604                    query.append(_FINDER_COLUMN_G_UT_URLTITLE_1);
2605                }
2606                else {
2607                    if (urlTitle.equals(StringPool.BLANK)) {
2608                        query.append(_FINDER_COLUMN_G_UT_URLTITLE_3);
2609                    }
2610                    else {
2611                        query.append(_FINDER_COLUMN_G_UT_URLTITLE_2);
2612                    }
2613                }
2614
2615                query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
2616
2617                String sql = query.toString();
2618
2619                Query q = session.createQuery(sql);
2620
2621                QueryPos qPos = QueryPos.getInstance(q);
2622
2623                qPos.add(groupId);
2624
2625                if (urlTitle != null) {
2626                    qPos.add(urlTitle);
2627                }
2628
2629                List<BlogsEntry> list = q.list();
2630
2631                result = list;
2632
2633                BlogsEntry blogsEntry = null;
2634
2635                if (list.isEmpty()) {
2636                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_UT,
2637                        finderArgs, list);
2638                }
2639                else {
2640                    blogsEntry = list.get(0);
2641
2642                    cacheResult(blogsEntry);
2643
2644                    if ((blogsEntry.getGroupId() != groupId) ||
2645                            (blogsEntry.getUrlTitle() == null) ||
2646                            !blogsEntry.getUrlTitle().equals(urlTitle)) {
2647                        FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_UT,
2648                            finderArgs, blogsEntry);
2649                    }
2650                }
2651
2652                return blogsEntry;
2653            }
2654            catch (Exception e) {
2655                throw processException(e);
2656            }
2657            finally {
2658                if (result == null) {
2659                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_UT,
2660                        finderArgs, new ArrayList<BlogsEntry>());
2661                }
2662
2663                closeSession(session);
2664            }
2665        }
2666        else {
2667            if (result instanceof List<?>) {
2668                return null;
2669            }
2670            else {
2671                return (BlogsEntry)result;
2672            }
2673        }
2674    }
2675
2676    public List<BlogsEntry> findByG_D(long groupId, Date displayDate)
2677        throws SystemException {
2678        return findByG_D(groupId, displayDate, QueryUtil.ALL_POS,
2679            QueryUtil.ALL_POS, null);
2680    }
2681
2682    public List<BlogsEntry> findByG_D(long groupId, Date displayDate,
2683        int start, int end) throws SystemException {
2684        return findByG_D(groupId, displayDate, start, end, null);
2685    }
2686
2687    public List<BlogsEntry> findByG_D(long groupId, Date displayDate,
2688        int start, int end, OrderByComparator orderByComparator)
2689        throws SystemException {
2690        Object[] finderArgs = new Object[] {
2691                new Long(groupId),
2692                
2693                displayDate,
2694                
2695                String.valueOf(start), String.valueOf(end),
2696                String.valueOf(orderByComparator)
2697            };
2698
2699        List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_D,
2700                finderArgs, this);
2701
2702        if (list == null) {
2703            Session session = null;
2704
2705            try {
2706                session = openSession();
2707
2708                StringBundler query = null;
2709
2710                if (orderByComparator != null) {
2711                    query = new StringBundler(4 +
2712                            (orderByComparator.getOrderByFields().length * 3));
2713                }
2714                else {
2715                    query = new StringBundler(4);
2716                }
2717
2718                query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
2719
2720                query.append(_FINDER_COLUMN_G_D_GROUPID_2);
2721
2722                if (displayDate == null) {
2723                    query.append(_FINDER_COLUMN_G_D_DISPLAYDATE_1);
2724                }
2725                else {
2726                    query.append(_FINDER_COLUMN_G_D_DISPLAYDATE_2);
2727                }
2728
2729                if (orderByComparator != null) {
2730                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2731                        orderByComparator);
2732                }
2733
2734                else {
2735                    query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
2736                }
2737
2738                String sql = query.toString();
2739
2740                Query q = session.createQuery(sql);
2741
2742                QueryPos qPos = QueryPos.getInstance(q);
2743
2744                qPos.add(groupId);
2745
2746                if (displayDate != null) {
2747                    qPos.add(CalendarUtil.getTimestamp(displayDate));
2748                }
2749
2750                list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start,
2751                        end);
2752            }
2753            catch (Exception e) {
2754                throw processException(e);
2755            }
2756            finally {
2757                if (list == null) {
2758                    list = new ArrayList<BlogsEntry>();
2759                }
2760
2761                cacheResult(list);
2762
2763                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_D, finderArgs,
2764                    list);
2765
2766                closeSession(session);
2767            }
2768        }
2769
2770        return list;
2771    }
2772
2773    public BlogsEntry findByG_D_First(long groupId, Date displayDate,
2774        OrderByComparator orderByComparator)
2775        throws NoSuchEntryException, SystemException {
2776        List<BlogsEntry> list = findByG_D(groupId, displayDate, 0, 1,
2777                orderByComparator);
2778
2779        if (list.isEmpty()) {
2780            StringBundler msg = new StringBundler(6);
2781
2782            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2783
2784            msg.append("groupId=");
2785            msg.append(groupId);
2786
2787            msg.append(", displayDate=");
2788            msg.append(displayDate);
2789
2790            msg.append(StringPool.CLOSE_CURLY_BRACE);
2791
2792            throw new NoSuchEntryException(msg.toString());
2793        }
2794        else {
2795            return list.get(0);
2796        }
2797    }
2798
2799    public BlogsEntry findByG_D_Last(long groupId, Date displayDate,
2800        OrderByComparator orderByComparator)
2801        throws NoSuchEntryException, SystemException {
2802        int count = countByG_D(groupId, displayDate);
2803
2804        List<BlogsEntry> list = findByG_D(groupId, displayDate, count - 1,
2805                count, orderByComparator);
2806
2807        if (list.isEmpty()) {
2808            StringBundler msg = new StringBundler(6);
2809
2810            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2811
2812            msg.append("groupId=");
2813            msg.append(groupId);
2814
2815            msg.append(", displayDate=");
2816            msg.append(displayDate);
2817
2818            msg.append(StringPool.CLOSE_CURLY_BRACE);
2819
2820            throw new NoSuchEntryException(msg.toString());
2821        }
2822        else {
2823            return list.get(0);
2824        }
2825    }
2826
2827    public BlogsEntry[] findByG_D_PrevAndNext(long entryId, long groupId,
2828        Date displayDate, OrderByComparator orderByComparator)
2829        throws NoSuchEntryException, SystemException {
2830        BlogsEntry blogsEntry = findByPrimaryKey(entryId);
2831
2832        Session session = null;
2833
2834        try {
2835            session = openSession();
2836
2837            BlogsEntry[] array = new BlogsEntryImpl[3];
2838
2839            array[0] = getByG_D_PrevAndNext(session, blogsEntry, groupId,
2840                    displayDate, orderByComparator, true);
2841
2842            array[1] = blogsEntry;
2843
2844            array[2] = getByG_D_PrevAndNext(session, blogsEntry, groupId,
2845                    displayDate, orderByComparator, false);
2846
2847            return array;
2848        }
2849        catch (Exception e) {
2850            throw processException(e);
2851        }
2852        finally {
2853            closeSession(session);
2854        }
2855    }
2856
2857    protected BlogsEntry getByG_D_PrevAndNext(Session session,
2858        BlogsEntry blogsEntry, long groupId, Date displayDate,
2859        OrderByComparator orderByComparator, boolean previous) {
2860        StringBundler query = null;
2861
2862        if (orderByComparator != null) {
2863            query = new StringBundler(6 +
2864                    (orderByComparator.getOrderByFields().length * 6));
2865        }
2866        else {
2867            query = new StringBundler(3);
2868        }
2869
2870        query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
2871
2872        query.append(_FINDER_COLUMN_G_D_GROUPID_2);
2873
2874        if (displayDate == null) {
2875            query.append(_FINDER_COLUMN_G_D_DISPLAYDATE_1);
2876        }
2877        else {
2878            query.append(_FINDER_COLUMN_G_D_DISPLAYDATE_2);
2879        }
2880
2881        if (orderByComparator != null) {
2882            String[] orderByFields = orderByComparator.getOrderByFields();
2883
2884            if (orderByFields.length > 0) {
2885                query.append(WHERE_AND);
2886            }
2887
2888            for (int i = 0; i < orderByFields.length; i++) {
2889                query.append(_ORDER_BY_ENTITY_ALIAS);
2890                query.append(orderByFields[i]);
2891
2892                if ((i + 1) < orderByFields.length) {
2893                    if (orderByComparator.isAscending() ^ previous) {
2894                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
2895                    }
2896                    else {
2897                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
2898                    }
2899                }
2900                else {
2901                    if (orderByComparator.isAscending() ^ previous) {
2902                        query.append(WHERE_GREATER_THAN);
2903                    }
2904                    else {
2905                        query.append(WHERE_LESSER_THAN);
2906                    }
2907                }
2908            }
2909
2910            query.append(ORDER_BY_CLAUSE);
2911
2912            for (int i = 0; i < orderByFields.length; i++) {
2913                query.append(_ORDER_BY_ENTITY_ALIAS);
2914                query.append(orderByFields[i]);
2915
2916                if ((i + 1) < orderByFields.length) {
2917                    if (orderByComparator.isAscending() ^ previous) {
2918                        query.append(ORDER_BY_ASC_HAS_NEXT);
2919                    }
2920                    else {
2921                        query.append(ORDER_BY_DESC_HAS_NEXT);
2922                    }
2923                }
2924                else {
2925                    if (orderByComparator.isAscending() ^ previous) {
2926                        query.append(ORDER_BY_ASC);
2927                    }
2928                    else {
2929                        query.append(ORDER_BY_DESC);
2930                    }
2931                }
2932            }
2933        }
2934
2935        else {
2936            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
2937        }
2938
2939        String sql = query.toString();
2940
2941        Query q = session.createQuery(sql);
2942
2943        q.setFirstResult(0);
2944        q.setMaxResults(2);
2945
2946        QueryPos qPos = QueryPos.getInstance(q);
2947
2948        qPos.add(groupId);
2949
2950        if (displayDate != null) {
2951            qPos.add(CalendarUtil.getTimestamp(displayDate));
2952        }
2953
2954        if (orderByComparator != null) {
2955            Object[] values = orderByComparator.getOrderByValues(blogsEntry);
2956
2957            for (Object value : values) {
2958                qPos.add(value);
2959            }
2960        }
2961
2962        List<BlogsEntry> list = q.list();
2963
2964        if (list.size() == 2) {
2965            return list.get(1);
2966        }
2967        else {
2968            return null;
2969        }
2970    }
2971
2972    public List<BlogsEntry> filterFindByG_D(long groupId, Date displayDate)
2973        throws SystemException {
2974        return filterFindByG_D(groupId, displayDate, QueryUtil.ALL_POS,
2975            QueryUtil.ALL_POS, null);
2976    }
2977
2978    public List<BlogsEntry> filterFindByG_D(long groupId, Date displayDate,
2979        int start, int end) throws SystemException {
2980        return filterFindByG_D(groupId, displayDate, start, end, null);
2981    }
2982
2983    public List<BlogsEntry> filterFindByG_D(long groupId, Date displayDate,
2984        int start, int end, OrderByComparator orderByComparator)
2985        throws SystemException {
2986        if (!InlineSQLHelperUtil.isEnabled(groupId)) {
2987            return findByG_D(groupId, displayDate, start, end, orderByComparator);
2988        }
2989
2990        Session session = null;
2991
2992        try {
2993            session = openSession();
2994
2995            StringBundler query = null;
2996
2997            if (orderByComparator != null) {
2998                query = new StringBundler(4 +
2999                        (orderByComparator.getOrderByFields().length * 3));
3000            }
3001            else {
3002                query = new StringBundler(4);
3003            }
3004
3005            query.append(_FILTER_SQL_SELECT_BLOGSENTRY_WHERE);
3006
3007            query.append(_FINDER_COLUMN_G_D_GROUPID_2);
3008
3009            if (displayDate == null) {
3010                query.append(_FINDER_COLUMN_G_D_DISPLAYDATE_1);
3011            }
3012            else {
3013                query.append(_FINDER_COLUMN_G_D_DISPLAYDATE_2);
3014            }
3015
3016            if (orderByComparator != null) {
3017                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
3018                    orderByComparator);
3019            }
3020
3021            else {
3022                query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
3023            }
3024
3025            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
3026                    BlogsEntry.class.getName(), _FILTER_COLUMN_ENTRYID,
3027                    _FILTER_COLUMN_USERID, groupId);
3028
3029            SQLQuery q = session.createSQLQuery(sql);
3030
3031            q.addEntity(_FILTER_ENTITY_ALIAS, BlogsEntryImpl.class);
3032
3033            QueryPos qPos = QueryPos.getInstance(q);
3034
3035            qPos.add(groupId);
3036
3037            if (displayDate != null) {
3038                qPos.add(CalendarUtil.getTimestamp(displayDate));
3039            }
3040
3041            return (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start, end);
3042        }
3043        catch (Exception e) {
3044            throw processException(e);
3045        }
3046        finally {
3047            closeSession(session);
3048        }
3049    }
3050
3051    public List<BlogsEntry> findByG_S(long groupId, int status)
3052        throws SystemException {
3053        return findByG_S(groupId, status, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
3054            null);
3055    }
3056
3057    public List<BlogsEntry> findByG_S(long groupId, int status, int start,
3058        int end) throws SystemException {
3059        return findByG_S(groupId, status, start, end, null);
3060    }
3061
3062    public List<BlogsEntry> findByG_S(long groupId, int status, int start,
3063        int end, OrderByComparator orderByComparator) throws SystemException {
3064        Object[] finderArgs = new Object[] {
3065                new Long(groupId), new Integer(status),
3066                
3067                String.valueOf(start), String.valueOf(end),
3068                String.valueOf(orderByComparator)
3069            };
3070
3071        List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_S,
3072                finderArgs, this);
3073
3074        if (list == null) {
3075            Session session = null;
3076
3077            try {
3078                session = openSession();
3079
3080                StringBundler query = null;
3081
3082                if (orderByComparator != null) {
3083                    query = new StringBundler(4 +
3084                            (orderByComparator.getOrderByFields().length * 3));
3085                }
3086                else {
3087                    query = new StringBundler(4);
3088                }
3089
3090                query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
3091
3092                query.append(_FINDER_COLUMN_G_S_GROUPID_2);
3093
3094                query.append(_FINDER_COLUMN_G_S_STATUS_2);
3095
3096                if (orderByComparator != null) {
3097                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
3098                        orderByComparator);
3099                }
3100
3101                else {
3102                    query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
3103                }
3104
3105                String sql = query.toString();
3106
3107                Query q = session.createQuery(sql);
3108
3109                QueryPos qPos = QueryPos.getInstance(q);
3110
3111                qPos.add(groupId);
3112
3113                qPos.add(status);
3114
3115                list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start,
3116                        end);
3117            }
3118            catch (Exception e) {
3119                throw processException(e);
3120            }
3121            finally {
3122                if (list == null) {
3123                    list = new ArrayList<BlogsEntry>();
3124                }
3125
3126                cacheResult(list);
3127
3128                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_S, finderArgs,
3129                    list);
3130
3131                closeSession(session);
3132            }
3133        }
3134
3135        return list;
3136    }
3137
3138    public BlogsEntry findByG_S_First(long groupId, int status,
3139        OrderByComparator orderByComparator)
3140        throws NoSuchEntryException, SystemException {
3141        List<BlogsEntry> list = findByG_S(groupId, status, 0, 1,
3142                orderByComparator);
3143
3144        if (list.isEmpty()) {
3145            StringBundler msg = new StringBundler(6);
3146
3147            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3148
3149            msg.append("groupId=");
3150            msg.append(groupId);
3151
3152            msg.append(", status=");
3153            msg.append(status);
3154
3155            msg.append(StringPool.CLOSE_CURLY_BRACE);
3156
3157            throw new NoSuchEntryException(msg.toString());
3158        }
3159        else {
3160            return list.get(0);
3161        }
3162    }
3163
3164    public BlogsEntry findByG_S_Last(long groupId, int status,
3165        OrderByComparator orderByComparator)
3166        throws NoSuchEntryException, SystemException {
3167        int count = countByG_S(groupId, status);
3168
3169        List<BlogsEntry> list = findByG_S(groupId, status, count - 1, count,
3170                orderByComparator);
3171
3172        if (list.isEmpty()) {
3173            StringBundler msg = new StringBundler(6);
3174
3175            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3176
3177            msg.append("groupId=");
3178            msg.append(groupId);
3179
3180            msg.append(", status=");
3181            msg.append(status);
3182
3183            msg.append(StringPool.CLOSE_CURLY_BRACE);
3184
3185            throw new NoSuchEntryException(msg.toString());
3186        }
3187        else {
3188            return list.get(0);
3189        }
3190    }
3191
3192    public BlogsEntry[] findByG_S_PrevAndNext(long entryId, long groupId,
3193        int status, OrderByComparator orderByComparator)
3194        throws NoSuchEntryException, SystemException {
3195        BlogsEntry blogsEntry = findByPrimaryKey(entryId);
3196
3197        Session session = null;
3198
3199        try {
3200            session = openSession();
3201
3202            BlogsEntry[] array = new BlogsEntryImpl[3];
3203
3204            array[0] = getByG_S_PrevAndNext(session, blogsEntry, groupId,
3205                    status, orderByComparator, true);
3206
3207            array[1] = blogsEntry;
3208
3209            array[2] = getByG_S_PrevAndNext(session, blogsEntry, groupId,
3210                    status, orderByComparator, false);
3211
3212            return array;
3213        }
3214        catch (Exception e) {
3215            throw processException(e);
3216        }
3217        finally {
3218            closeSession(session);
3219        }
3220    }
3221
3222    protected BlogsEntry getByG_S_PrevAndNext(Session session,
3223        BlogsEntry blogsEntry, long groupId, int status,
3224        OrderByComparator orderByComparator, boolean previous) {
3225        StringBundler query = null;
3226
3227        if (orderByComparator != null) {
3228            query = new StringBundler(6 +
3229                    (orderByComparator.getOrderByFields().length * 6));
3230        }
3231        else {
3232            query = new StringBundler(3);
3233        }
3234
3235        query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
3236
3237        query.append(_FINDER_COLUMN_G_S_GROUPID_2);
3238
3239        query.append(_FINDER_COLUMN_G_S_STATUS_2);
3240
3241        if (orderByComparator != null) {
3242            String[] orderByFields = orderByComparator.getOrderByFields();
3243
3244            if (orderByFields.length > 0) {
3245                query.append(WHERE_AND);
3246            }
3247
3248            for (int i = 0; i < orderByFields.length; i++) {
3249                query.append(_ORDER_BY_ENTITY_ALIAS);
3250                query.append(orderByFields[i]);
3251
3252                if ((i + 1) < orderByFields.length) {
3253                    if (orderByComparator.isAscending() ^ previous) {
3254                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
3255                    }
3256                    else {
3257                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
3258                    }
3259                }
3260                else {
3261                    if (orderByComparator.isAscending() ^ previous) {
3262                        query.append(WHERE_GREATER_THAN);
3263                    }
3264                    else {
3265                        query.append(WHERE_LESSER_THAN);
3266                    }
3267                }
3268            }
3269
3270            query.append(ORDER_BY_CLAUSE);
3271
3272            for (int i = 0; i < orderByFields.length; i++) {
3273                query.append(_ORDER_BY_ENTITY_ALIAS);
3274                query.append(orderByFields[i]);
3275
3276                if ((i + 1) < orderByFields.length) {
3277                    if (orderByComparator.isAscending() ^ previous) {
3278                        query.append(ORDER_BY_ASC_HAS_NEXT);
3279                    }
3280                    else {
3281                        query.append(ORDER_BY_DESC_HAS_NEXT);
3282                    }
3283                }
3284                else {
3285                    if (orderByComparator.isAscending() ^ previous) {
3286                        query.append(ORDER_BY_ASC);
3287                    }
3288                    else {
3289                        query.append(ORDER_BY_DESC);
3290                    }
3291                }
3292            }
3293        }
3294
3295        else {
3296            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
3297        }
3298
3299        String sql = query.toString();
3300
3301        Query q = session.createQuery(sql);
3302
3303        q.setFirstResult(0);
3304        q.setMaxResults(2);
3305
3306        QueryPos qPos = QueryPos.getInstance(q);
3307
3308        qPos.add(groupId);
3309
3310        qPos.add(status);
3311
3312        if (orderByComparator != null) {
3313            Object[] values = orderByComparator.getOrderByValues(blogsEntry);
3314
3315            for (Object value : values) {
3316                qPos.add(value);
3317            }
3318        }
3319
3320        List<BlogsEntry> list = q.list();
3321
3322        if (list.size() == 2) {
3323            return list.get(1);
3324        }
3325        else {
3326            return null;
3327        }
3328    }
3329
3330    public List<BlogsEntry> filterFindByG_S(long groupId, int status)
3331        throws SystemException {
3332        return filterFindByG_S(groupId, status, QueryUtil.ALL_POS,
3333            QueryUtil.ALL_POS, null);
3334    }
3335
3336    public List<BlogsEntry> filterFindByG_S(long groupId, int status,
3337        int start, int end) throws SystemException {
3338        return filterFindByG_S(groupId, status, start, end, null);
3339    }
3340
3341    public List<BlogsEntry> filterFindByG_S(long groupId, int status,
3342        int start, int end, OrderByComparator orderByComparator)
3343        throws SystemException {
3344        if (!InlineSQLHelperUtil.isEnabled(groupId)) {
3345            return findByG_S(groupId, status, start, end, orderByComparator);
3346        }
3347
3348        Session session = null;
3349
3350        try {
3351            session = openSession();
3352
3353            StringBundler query = null;
3354
3355            if (orderByComparator != null) {
3356                query = new StringBundler(4 +
3357                        (orderByComparator.getOrderByFields().length * 3));
3358            }
3359            else {
3360                query = new StringBundler(4);
3361            }
3362
3363            query.append(_FILTER_SQL_SELECT_BLOGSENTRY_WHERE);
3364
3365            query.append(_FINDER_COLUMN_G_S_GROUPID_2);
3366
3367            query.append(_FINDER_COLUMN_G_S_STATUS_2);
3368
3369            if (orderByComparator != null) {
3370                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
3371                    orderByComparator);
3372            }
3373
3374            else {
3375                query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
3376            }
3377
3378            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
3379                    BlogsEntry.class.getName(), _FILTER_COLUMN_ENTRYID,
3380                    _FILTER_COLUMN_USERID, groupId);
3381
3382            SQLQuery q = session.createSQLQuery(sql);
3383
3384            q.addEntity(_FILTER_ENTITY_ALIAS, BlogsEntryImpl.class);
3385
3386            QueryPos qPos = QueryPos.getInstance(q);
3387
3388            qPos.add(groupId);
3389
3390            qPos.add(status);
3391
3392            return (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start, end);
3393        }
3394        catch (Exception e) {
3395            throw processException(e);
3396        }
3397        finally {
3398            closeSession(session);
3399        }
3400    }
3401
3402    public List<BlogsEntry> findByC_U_S(long companyId, long userId, int status)
3403        throws SystemException {
3404        return findByC_U_S(companyId, userId, status, QueryUtil.ALL_POS,
3405            QueryUtil.ALL_POS, null);
3406    }
3407
3408    public List<BlogsEntry> findByC_U_S(long companyId, long userId,
3409        int status, int start, int end) throws SystemException {
3410        return findByC_U_S(companyId, userId, status, start, end, null);
3411    }
3412
3413    public List<BlogsEntry> findByC_U_S(long companyId, long userId,
3414        int status, int start, int end, OrderByComparator orderByComparator)
3415        throws SystemException {
3416        Object[] finderArgs = new Object[] {
3417                new Long(companyId), new Long(userId), new Integer(status),
3418                
3419                String.valueOf(start), String.valueOf(end),
3420                String.valueOf(orderByComparator)
3421            };
3422
3423        List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_C_U_S,
3424                finderArgs, this);
3425
3426        if (list == null) {
3427            Session session = null;
3428
3429            try {
3430                session = openSession();
3431
3432                StringBundler query = null;
3433
3434                if (orderByComparator != null) {
3435                    query = new StringBundler(5 +
3436                            (orderByComparator.getOrderByFields().length * 3));
3437                }
3438                else {
3439                    query = new StringBundler(5);
3440                }
3441
3442                query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
3443
3444                query.append(_FINDER_COLUMN_C_U_S_COMPANYID_2);
3445
3446                query.append(_FINDER_COLUMN_C_U_S_USERID_2);
3447
3448                query.append(_FINDER_COLUMN_C_U_S_STATUS_2);
3449
3450                if (orderByComparator != null) {
3451                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
3452                        orderByComparator);
3453                }
3454
3455                else {
3456                    query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
3457                }
3458
3459                String sql = query.toString();
3460
3461                Query q = session.createQuery(sql);
3462
3463                QueryPos qPos = QueryPos.getInstance(q);
3464
3465                qPos.add(companyId);
3466
3467                qPos.add(userId);
3468
3469                qPos.add(status);
3470
3471                list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start,
3472                        end);
3473            }
3474            catch (Exception e) {
3475                throw processException(e);
3476            }
3477            finally {
3478                if (list == null) {
3479                    list = new ArrayList<BlogsEntry>();
3480                }
3481
3482                cacheResult(list);
3483
3484                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_C_U_S,
3485                    finderArgs, list);
3486
3487                closeSession(session);
3488            }
3489        }
3490
3491        return list;
3492    }
3493
3494    public BlogsEntry findByC_U_S_First(long companyId, long userId,
3495        int status, OrderByComparator orderByComparator)
3496        throws NoSuchEntryException, SystemException {
3497        List<BlogsEntry> list = findByC_U_S(companyId, userId, status, 0, 1,
3498                orderByComparator);
3499
3500        if (list.isEmpty()) {
3501            StringBundler msg = new StringBundler(8);
3502
3503            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3504
3505            msg.append("companyId=");
3506            msg.append(companyId);
3507
3508            msg.append(", userId=");
3509            msg.append(userId);
3510
3511            msg.append(", status=");
3512            msg.append(status);
3513
3514            msg.append(StringPool.CLOSE_CURLY_BRACE);
3515
3516            throw new NoSuchEntryException(msg.toString());
3517        }
3518        else {
3519            return list.get(0);
3520        }
3521    }
3522
3523    public BlogsEntry findByC_U_S_Last(long companyId, long userId, int status,
3524        OrderByComparator orderByComparator)
3525        throws NoSuchEntryException, SystemException {
3526        int count = countByC_U_S(companyId, userId, status);
3527
3528        List<BlogsEntry> list = findByC_U_S(companyId, userId, status,
3529                count - 1, count, orderByComparator);
3530
3531        if (list.isEmpty()) {
3532            StringBundler msg = new StringBundler(8);
3533
3534            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3535
3536            msg.append("companyId=");
3537            msg.append(companyId);
3538
3539            msg.append(", userId=");
3540            msg.append(userId);
3541
3542            msg.append(", status=");
3543            msg.append(status);
3544
3545            msg.append(StringPool.CLOSE_CURLY_BRACE);
3546
3547            throw new NoSuchEntryException(msg.toString());
3548        }
3549        else {
3550            return list.get(0);
3551        }
3552    }
3553
3554    public BlogsEntry[] findByC_U_S_PrevAndNext(long entryId, long companyId,
3555        long userId, int status, OrderByComparator orderByComparator)
3556        throws NoSuchEntryException, SystemException {
3557        BlogsEntry blogsEntry = findByPrimaryKey(entryId);
3558
3559        Session session = null;
3560
3561        try {
3562            session = openSession();
3563
3564            BlogsEntry[] array = new BlogsEntryImpl[3];
3565
3566            array[0] = getByC_U_S_PrevAndNext(session, blogsEntry, companyId,
3567                    userId, status, orderByComparator, true);
3568
3569            array[1] = blogsEntry;
3570
3571            array[2] = getByC_U_S_PrevAndNext(session, blogsEntry, companyId,
3572                    userId, status, orderByComparator, false);
3573
3574            return array;
3575        }
3576        catch (Exception e) {
3577            throw processException(e);
3578        }
3579        finally {
3580            closeSession(session);
3581        }
3582    }
3583
3584    protected BlogsEntry getByC_U_S_PrevAndNext(Session session,
3585        BlogsEntry blogsEntry, long companyId, long userId, int status,
3586        OrderByComparator orderByComparator, boolean previous) {
3587        StringBundler query = null;
3588
3589        if (orderByComparator != null) {
3590            query = new StringBundler(6 +
3591                    (orderByComparator.getOrderByFields().length * 6));
3592        }
3593        else {
3594            query = new StringBundler(3);
3595        }
3596
3597        query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
3598
3599        query.append(_FINDER_COLUMN_C_U_S_COMPANYID_2);
3600
3601        query.append(_FINDER_COLUMN_C_U_S_USERID_2);
3602
3603        query.append(_FINDER_COLUMN_C_U_S_STATUS_2);
3604
3605        if (orderByComparator != null) {
3606            String[] orderByFields = orderByComparator.getOrderByFields();
3607
3608            if (orderByFields.length > 0) {
3609                query.append(WHERE_AND);
3610            }
3611
3612            for (int i = 0; i < orderByFields.length; i++) {
3613                query.append(_ORDER_BY_ENTITY_ALIAS);
3614                query.append(orderByFields[i]);
3615
3616                if ((i + 1) < orderByFields.length) {
3617                    if (orderByComparator.isAscending() ^ previous) {
3618                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
3619                    }
3620                    else {
3621                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
3622                    }
3623                }
3624                else {
3625                    if (orderByComparator.isAscending() ^ previous) {
3626                        query.append(WHERE_GREATER_THAN);
3627                    }
3628                    else {
3629                        query.append(WHERE_LESSER_THAN);
3630                    }
3631                }
3632            }
3633
3634            query.append(ORDER_BY_CLAUSE);
3635
3636            for (int i = 0; i < orderByFields.length; i++) {
3637                query.append(_ORDER_BY_ENTITY_ALIAS);
3638                query.append(orderByFields[i]);
3639
3640                if ((i + 1) < orderByFields.length) {
3641                    if (orderByComparator.isAscending() ^ previous) {
3642                        query.append(ORDER_BY_ASC_HAS_NEXT);
3643                    }
3644                    else {
3645                        query.append(ORDER_BY_DESC_HAS_NEXT);
3646                    }
3647                }
3648                else {
3649                    if (orderByComparator.isAscending() ^ previous) {
3650                        query.append(ORDER_BY_ASC);
3651                    }
3652                    else {
3653                        query.append(ORDER_BY_DESC);
3654                    }
3655                }
3656            }
3657        }
3658
3659        else {
3660            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
3661        }
3662
3663        String sql = query.toString();
3664
3665        Query q = session.createQuery(sql);
3666
3667        q.setFirstResult(0);
3668        q.setMaxResults(2);
3669
3670        QueryPos qPos = QueryPos.getInstance(q);
3671
3672        qPos.add(companyId);
3673
3674        qPos.add(userId);
3675
3676        qPos.add(status);
3677
3678        if (orderByComparator != null) {
3679            Object[] values = orderByComparator.getOrderByValues(blogsEntry);
3680
3681            for (Object value : values) {
3682                qPos.add(value);
3683            }
3684        }
3685
3686        List<BlogsEntry> list = q.list();
3687
3688        if (list.size() == 2) {
3689            return list.get(1);
3690        }
3691        else {
3692            return null;
3693        }
3694    }
3695
3696    public List<BlogsEntry> findByC_D_S(long companyId, Date displayDate,
3697        int status) throws SystemException {
3698        return findByC_D_S(companyId, displayDate, status, QueryUtil.ALL_POS,
3699            QueryUtil.ALL_POS, null);
3700    }
3701
3702    public List<BlogsEntry> findByC_D_S(long companyId, Date displayDate,
3703        int status, int start, int end) throws SystemException {
3704        return findByC_D_S(companyId, displayDate, status, start, end, null);
3705    }
3706
3707    public List<BlogsEntry> findByC_D_S(long companyId, Date displayDate,
3708        int status, int start, int end, OrderByComparator orderByComparator)
3709        throws SystemException {
3710        Object[] finderArgs = new Object[] {
3711                new Long(companyId),
3712                
3713                displayDate, new Integer(status),
3714                
3715                String.valueOf(start), String.valueOf(end),
3716                String.valueOf(orderByComparator)
3717            };
3718
3719        List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_C_D_S,
3720                finderArgs, this);
3721
3722        if (list == null) {
3723            Session session = null;
3724
3725            try {
3726                session = openSession();
3727
3728                StringBundler query = null;
3729
3730                if (orderByComparator != null) {
3731                    query = new StringBundler(5 +
3732                            (orderByComparator.getOrderByFields().length * 3));
3733                }
3734                else {
3735                    query = new StringBundler(5);
3736                }
3737
3738                query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
3739
3740                query.append(_FINDER_COLUMN_C_D_S_COMPANYID_2);
3741
3742                if (displayDate == null) {
3743                    query.append(_FINDER_COLUMN_C_D_S_DISPLAYDATE_1);
3744                }
3745                else {
3746                    query.append(_FINDER_COLUMN_C_D_S_DISPLAYDATE_2);
3747                }
3748
3749                query.append(_FINDER_COLUMN_C_D_S_STATUS_2);
3750
3751                if (orderByComparator != null) {
3752                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
3753                        orderByComparator);
3754                }
3755
3756                else {
3757                    query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
3758                }
3759
3760                String sql = query.toString();
3761
3762                Query q = session.createQuery(sql);
3763
3764                QueryPos qPos = QueryPos.getInstance(q);
3765
3766                qPos.add(companyId);
3767
3768                if (displayDate != null) {
3769                    qPos.add(CalendarUtil.getTimestamp(displayDate));
3770                }
3771
3772                qPos.add(status);
3773
3774                list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start,
3775                        end);
3776            }
3777            catch (Exception e) {
3778                throw processException(e);
3779            }
3780            finally {
3781                if (list == null) {
3782                    list = new ArrayList<BlogsEntry>();
3783                }
3784
3785                cacheResult(list);
3786
3787                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_C_D_S,
3788                    finderArgs, list);
3789
3790                closeSession(session);
3791            }
3792        }
3793
3794        return list;
3795    }
3796
3797    public BlogsEntry findByC_D_S_First(long companyId, Date displayDate,
3798        int status, OrderByComparator orderByComparator)
3799        throws NoSuchEntryException, SystemException {
3800        List<BlogsEntry> list = findByC_D_S(companyId, displayDate, status, 0,
3801                1, orderByComparator);
3802
3803        if (list.isEmpty()) {
3804            StringBundler msg = new StringBundler(8);
3805
3806            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3807
3808            msg.append("companyId=");
3809            msg.append(companyId);
3810
3811            msg.append(", displayDate=");
3812            msg.append(displayDate);
3813
3814            msg.append(", status=");
3815            msg.append(status);
3816
3817            msg.append(StringPool.CLOSE_CURLY_BRACE);
3818
3819            throw new NoSuchEntryException(msg.toString());
3820        }
3821        else {
3822            return list.get(0);
3823        }
3824    }
3825
3826    public BlogsEntry findByC_D_S_Last(long companyId, Date displayDate,
3827        int status, OrderByComparator orderByComparator)
3828        throws NoSuchEntryException, SystemException {
3829        int count = countByC_D_S(companyId, displayDate, status);
3830
3831        List<BlogsEntry> list = findByC_D_S(companyId, displayDate, status,
3832                count - 1, count, orderByComparator);
3833
3834        if (list.isEmpty()) {
3835            StringBundler msg = new StringBundler(8);
3836
3837            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3838
3839            msg.append("companyId=");
3840            msg.append(companyId);
3841
3842            msg.append(", displayDate=");
3843            msg.append(displayDate);
3844
3845            msg.append(", status=");
3846            msg.append(status);
3847
3848            msg.append(StringPool.CLOSE_CURLY_BRACE);
3849
3850            throw new NoSuchEntryException(msg.toString());
3851        }
3852        else {
3853            return list.get(0);
3854        }
3855    }
3856
3857    public BlogsEntry[] findByC_D_S_PrevAndNext(long entryId, long companyId,
3858        Date displayDate, int status, OrderByComparator orderByComparator)
3859        throws NoSuchEntryException, SystemException {
3860        BlogsEntry blogsEntry = findByPrimaryKey(entryId);
3861
3862        Session session = null;
3863
3864        try {
3865            session = openSession();
3866
3867            BlogsEntry[] array = new BlogsEntryImpl[3];
3868
3869            array[0] = getByC_D_S_PrevAndNext(session, blogsEntry, companyId,
3870                    displayDate, status, orderByComparator, true);
3871
3872            array[1] = blogsEntry;
3873
3874            array[2] = getByC_D_S_PrevAndNext(session, blogsEntry, companyId,
3875                    displayDate, status, orderByComparator, false);
3876
3877            return array;
3878        }
3879        catch (Exception e) {
3880            throw processException(e);
3881        }
3882        finally {
3883            closeSession(session);
3884        }
3885    }
3886
3887    protected BlogsEntry getByC_D_S_PrevAndNext(Session session,
3888        BlogsEntry blogsEntry, long companyId, Date displayDate, int status,
3889        OrderByComparator orderByComparator, boolean previous) {
3890        StringBundler query = null;
3891
3892        if (orderByComparator != null) {
3893            query = new StringBundler(6 +
3894                    (orderByComparator.getOrderByFields().length * 6));
3895        }
3896        else {
3897            query = new StringBundler(3);
3898        }
3899
3900        query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
3901
3902        query.append(_FINDER_COLUMN_C_D_S_COMPANYID_2);
3903
3904        if (displayDate == null) {
3905            query.append(_FINDER_COLUMN_C_D_S_DISPLAYDATE_1);
3906        }
3907        else {
3908            query.append(_FINDER_COLUMN_C_D_S_DISPLAYDATE_2);
3909        }
3910
3911        query.append(_FINDER_COLUMN_C_D_S_STATUS_2);
3912
3913        if (orderByComparator != null) {
3914            String[] orderByFields = orderByComparator.getOrderByFields();
3915
3916            if (orderByFields.length > 0) {
3917                query.append(WHERE_AND);
3918            }
3919
3920            for (int i = 0; i < orderByFields.length; i++) {
3921                query.append(_ORDER_BY_ENTITY_ALIAS);
3922                query.append(orderByFields[i]);
3923
3924                if ((i + 1) < orderByFields.length) {
3925                    if (orderByComparator.isAscending() ^ previous) {
3926                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
3927                    }
3928                    else {
3929                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
3930                    }
3931                }
3932                else {
3933                    if (orderByComparator.isAscending() ^ previous) {
3934                        query.append(WHERE_GREATER_THAN);
3935                    }
3936                    else {
3937                        query.append(WHERE_LESSER_THAN);
3938                    }
3939                }
3940            }
3941
3942            query.append(ORDER_BY_CLAUSE);
3943
3944            for (int i = 0; i < orderByFields.length; i++) {
3945                query.append(_ORDER_BY_ENTITY_ALIAS);
3946                query.append(orderByFields[i]);
3947
3948                if ((i + 1) < orderByFields.length) {
3949                    if (orderByComparator.isAscending() ^ previous) {
3950                        query.append(ORDER_BY_ASC_HAS_NEXT);
3951                    }
3952                    else {
3953                        query.append(ORDER_BY_DESC_HAS_NEXT);
3954                    }
3955                }
3956                else {
3957                    if (orderByComparator.isAscending() ^ previous) {
3958                        query.append(ORDER_BY_ASC);
3959                    }
3960                    else {
3961                        query.append(ORDER_BY_DESC);
3962                    }
3963                }
3964            }
3965        }
3966
3967        else {
3968            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
3969        }
3970
3971        String sql = query.toString();
3972
3973        Query q = session.createQuery(sql);
3974
3975        q.setFirstResult(0);
3976        q.setMaxResults(2);
3977
3978        QueryPos qPos = QueryPos.getInstance(q);
3979
3980        qPos.add(companyId);
3981
3982        if (displayDate != null) {
3983            qPos.add(CalendarUtil.getTimestamp(displayDate));
3984        }
3985
3986        qPos.add(status);
3987
3988        if (orderByComparator != null) {
3989            Object[] values = orderByComparator.getOrderByValues(blogsEntry);
3990
3991            for (Object value : values) {
3992                qPos.add(value);
3993            }
3994        }
3995
3996        List<BlogsEntry> list = q.list();
3997
3998        if (list.size() == 2) {
3999            return list.get(1);
4000        }
4001        else {
4002            return null;
4003        }
4004    }
4005
4006    public List<BlogsEntry> findByG_U_D(long groupId, long userId,
4007        Date displayDate) throws SystemException {
4008        return findByG_U_D(groupId, userId, displayDate, QueryUtil.ALL_POS,
4009            QueryUtil.ALL_POS, null);
4010    }
4011
4012    public List<BlogsEntry> findByG_U_D(long groupId, long userId,
4013        Date displayDate, int start, int end) throws SystemException {
4014        return findByG_U_D(groupId, userId, displayDate, start, end, null);
4015    }
4016
4017    public List<BlogsEntry> findByG_U_D(long groupId, long userId,
4018        Date displayDate, int start, int end,
4019        OrderByComparator orderByComparator) throws SystemException {
4020        Object[] finderArgs = new Object[] {
4021                new Long(groupId), new Long(userId),
4022                
4023                displayDate,
4024                
4025                String.valueOf(start), String.valueOf(end),
4026                String.valueOf(orderByComparator)
4027            };
4028
4029        List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_U_D,
4030                finderArgs, this);
4031
4032        if (list == null) {
4033            Session session = null;
4034
4035            try {
4036                session = openSession();
4037
4038                StringBundler query = null;
4039
4040                if (orderByComparator != null) {
4041                    query = new StringBundler(5 +
4042                            (orderByComparator.getOrderByFields().length * 3));
4043                }
4044                else {
4045                    query = new StringBundler(5);
4046                }
4047
4048                query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
4049
4050                query.append(_FINDER_COLUMN_G_U_D_GROUPID_2);
4051
4052                query.append(_FINDER_COLUMN_G_U_D_USERID_2);
4053
4054                if (displayDate == null) {
4055                    query.append(_FINDER_COLUMN_G_U_D_DISPLAYDATE_1);
4056                }
4057                else {
4058                    query.append(_FINDER_COLUMN_G_U_D_DISPLAYDATE_2);
4059                }
4060
4061                if (orderByComparator != null) {
4062                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
4063                        orderByComparator);
4064                }
4065
4066                else {
4067                    query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
4068                }
4069
4070                String sql = query.toString();
4071
4072                Query q = session.createQuery(sql);
4073
4074                QueryPos qPos = QueryPos.getInstance(q);
4075
4076                qPos.add(groupId);
4077
4078                qPos.add(userId);
4079
4080                if (displayDate != null) {
4081                    qPos.add(CalendarUtil.getTimestamp(displayDate));
4082                }
4083
4084                list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start,
4085                        end);
4086            }
4087            catch (Exception e) {
4088                throw processException(e);
4089            }
4090            finally {
4091                if (list == null) {
4092                    list = new ArrayList<BlogsEntry>();
4093                }
4094
4095                cacheResult(list);
4096
4097                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_U_D,
4098                    finderArgs, list);
4099
4100                closeSession(session);
4101            }
4102        }
4103
4104        return list;
4105    }
4106
4107    public BlogsEntry findByG_U_D_First(long groupId, long userId,
4108        Date displayDate, OrderByComparator orderByComparator)
4109        throws NoSuchEntryException, SystemException {
4110        List<BlogsEntry> list = findByG_U_D(groupId, userId, displayDate, 0, 1,
4111                orderByComparator);
4112
4113        if (list.isEmpty()) {
4114            StringBundler msg = new StringBundler(8);
4115
4116            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
4117
4118            msg.append("groupId=");
4119            msg.append(groupId);
4120
4121            msg.append(", userId=");
4122            msg.append(userId);
4123
4124            msg.append(", displayDate=");
4125            msg.append(displayDate);
4126
4127            msg.append(StringPool.CLOSE_CURLY_BRACE);
4128
4129            throw new NoSuchEntryException(msg.toString());
4130        }
4131        else {
4132            return list.get(0);
4133        }
4134    }
4135
4136    public BlogsEntry findByG_U_D_Last(long groupId, long userId,
4137        Date displayDate, OrderByComparator orderByComparator)
4138        throws NoSuchEntryException, SystemException {
4139        int count = countByG_U_D(groupId, userId, displayDate);
4140
4141        List<BlogsEntry> list = findByG_U_D(groupId, userId, displayDate,
4142                count - 1, count, orderByComparator);
4143
4144        if (list.isEmpty()) {
4145            StringBundler msg = new StringBundler(8);
4146
4147            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
4148
4149            msg.append("groupId=");
4150            msg.append(groupId);
4151
4152            msg.append(", userId=");
4153            msg.append(userId);
4154
4155            msg.append(", displayDate=");
4156            msg.append(displayDate);
4157
4158            msg.append(StringPool.CLOSE_CURLY_BRACE);
4159
4160            throw new NoSuchEntryException(msg.toString());
4161        }
4162        else {
4163            return list.get(0);
4164        }
4165    }
4166
4167    public BlogsEntry[] findByG_U_D_PrevAndNext(long entryId, long groupId,
4168        long userId, Date displayDate, OrderByComparator orderByComparator)
4169        throws NoSuchEntryException, SystemException {
4170        BlogsEntry blogsEntry = findByPrimaryKey(entryId);
4171
4172        Session session = null;
4173
4174        try {
4175            session = openSession();
4176
4177            BlogsEntry[] array = new BlogsEntryImpl[3];
4178
4179            array[0] = getByG_U_D_PrevAndNext(session, blogsEntry, groupId,
4180                    userId, displayDate, orderByComparator, true);
4181
4182            array[1] = blogsEntry;
4183
4184            array[2] = getByG_U_D_PrevAndNext(session, blogsEntry, groupId,
4185                    userId, displayDate, orderByComparator, false);
4186
4187            return array;
4188        }
4189        catch (Exception e) {
4190            throw processException(e);
4191        }
4192        finally {
4193            closeSession(session);
4194        }
4195    }
4196
4197    protected BlogsEntry getByG_U_D_PrevAndNext(Session session,
4198        BlogsEntry blogsEntry, long groupId, long userId, Date displayDate,
4199        OrderByComparator orderByComparator, boolean previous) {
4200        StringBundler query = null;
4201
4202        if (orderByComparator != null) {
4203            query = new StringBundler(6 +
4204                    (orderByComparator.getOrderByFields().length * 6));
4205        }
4206        else {
4207            query = new StringBundler(3);
4208        }
4209
4210        query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
4211
4212        query.append(_FINDER_COLUMN_G_U_D_GROUPID_2);
4213
4214        query.append(_FINDER_COLUMN_G_U_D_USERID_2);
4215
4216        if (displayDate == null) {
4217            query.append(_FINDER_COLUMN_G_U_D_DISPLAYDATE_1);
4218        }
4219        else {
4220            query.append(_FINDER_COLUMN_G_U_D_DISPLAYDATE_2);
4221        }
4222
4223        if (orderByComparator != null) {
4224            String[] orderByFields = orderByComparator.getOrderByFields();
4225
4226            if (orderByFields.length > 0) {
4227                query.append(WHERE_AND);
4228            }
4229
4230            for (int i = 0; i < orderByFields.length; i++) {
4231                query.append(_ORDER_BY_ENTITY_ALIAS);
4232                query.append(orderByFields[i]);
4233
4234                if ((i + 1) < orderByFields.length) {
4235                    if (orderByComparator.isAscending() ^ previous) {
4236                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
4237                    }
4238                    else {
4239                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
4240                    }
4241                }
4242                else {
4243                    if (orderByComparator.isAscending() ^ previous) {
4244                        query.append(WHERE_GREATER_THAN);
4245                    }
4246                    else {
4247                        query.append(WHERE_LESSER_THAN);
4248                    }
4249                }
4250            }
4251
4252            query.append(ORDER_BY_CLAUSE);
4253
4254            for (int i = 0; i < orderByFields.length; i++) {
4255                query.append(_ORDER_BY_ENTITY_ALIAS);
4256                query.append(orderByFields[i]);
4257
4258                if ((i + 1) < orderByFields.length) {
4259                    if (orderByComparator.isAscending() ^ previous) {
4260                        query.append(ORDER_BY_ASC_HAS_NEXT);
4261                    }
4262                    else {
4263                        query.append(ORDER_BY_DESC_HAS_NEXT);
4264                    }
4265                }
4266                else {
4267                    if (orderByComparator.isAscending() ^ previous) {
4268                        query.append(ORDER_BY_ASC);
4269                    }
4270                    else {
4271                        query.append(ORDER_BY_DESC);
4272                    }
4273                }
4274            }
4275        }
4276
4277        else {
4278            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
4279        }
4280
4281        String sql = query.toString();
4282
4283        Query q = session.createQuery(sql);
4284
4285        q.setFirstResult(0);
4286        q.setMaxResults(2);
4287
4288        QueryPos qPos = QueryPos.getInstance(q);
4289
4290        qPos.add(groupId);
4291
4292        qPos.add(userId);
4293
4294        if (displayDate != null) {
4295            qPos.add(CalendarUtil.getTimestamp(displayDate));
4296        }
4297
4298        if (orderByComparator != null) {
4299            Object[] values = orderByComparator.getOrderByValues(blogsEntry);
4300
4301            for (Object value : values) {
4302                qPos.add(value);
4303            }
4304        }
4305
4306        List<BlogsEntry> list = q.list();
4307
4308        if (list.size() == 2) {
4309            return list.get(1);
4310        }
4311        else {
4312            return null;
4313        }
4314    }
4315
4316    public List<BlogsEntry> filterFindByG_U_D(long groupId, long userId,
4317        Date displayDate) throws SystemException {
4318        return filterFindByG_U_D(groupId, userId, displayDate,
4319            QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
4320    }
4321
4322    public List<BlogsEntry> filterFindByG_U_D(long groupId, long userId,
4323        Date displayDate, int start, int end) throws SystemException {
4324        return filterFindByG_U_D(groupId, userId, displayDate, start, end, null);
4325    }
4326
4327    public List<BlogsEntry> filterFindByG_U_D(long groupId, long userId,
4328        Date displayDate, int start, int end,
4329        OrderByComparator orderByComparator) throws SystemException {
4330        if (!InlineSQLHelperUtil.isEnabled(groupId)) {
4331            return findByG_U_D(groupId, userId, displayDate, start, end,
4332                orderByComparator);
4333        }
4334
4335        Session session = null;
4336
4337        try {
4338            session = openSession();
4339
4340            StringBundler query = null;
4341
4342            if (orderByComparator != null) {
4343                query = new StringBundler(5 +
4344                        (orderByComparator.getOrderByFields().length * 3));
4345            }
4346            else {
4347                query = new StringBundler(5);
4348            }
4349
4350            query.append(_FILTER_SQL_SELECT_BLOGSENTRY_WHERE);
4351
4352            query.append(_FINDER_COLUMN_G_U_D_GROUPID_2);
4353
4354            query.append(_FINDER_COLUMN_G_U_D_USERID_2);
4355
4356            if (displayDate == null) {
4357                query.append(_FINDER_COLUMN_G_U_D_DISPLAYDATE_1);
4358            }
4359            else {
4360                query.append(_FINDER_COLUMN_G_U_D_DISPLAYDATE_2);
4361            }
4362
4363            if (orderByComparator != null) {
4364                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
4365                    orderByComparator);
4366            }
4367
4368            else {
4369                query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
4370            }
4371
4372            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
4373                    BlogsEntry.class.getName(), _FILTER_COLUMN_ENTRYID,
4374                    _FILTER_COLUMN_USERID, groupId);
4375
4376            SQLQuery q = session.createSQLQuery(sql);
4377
4378            q.addEntity(_FILTER_ENTITY_ALIAS, BlogsEntryImpl.class);
4379
4380            QueryPos qPos = QueryPos.getInstance(q);
4381
4382            qPos.add(groupId);
4383
4384            qPos.add(userId);
4385
4386            if (displayDate != null) {
4387                qPos.add(CalendarUtil.getTimestamp(displayDate));
4388            }
4389
4390            return (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start, end);
4391        }
4392        catch (Exception e) {
4393            throw processException(e);
4394        }
4395        finally {
4396            closeSession(session);
4397        }
4398    }
4399
4400    public List<BlogsEntry> findByG_U_S(long groupId, long userId, int status)
4401        throws SystemException {
4402        return findByG_U_S(groupId, userId, status, QueryUtil.ALL_POS,
4403            QueryUtil.ALL_POS, null);
4404    }
4405
4406    public List<BlogsEntry> findByG_U_S(long groupId, long userId, int status,
4407        int start, int end) throws SystemException {
4408        return findByG_U_S(groupId, userId, status, start, end, null);
4409    }
4410
4411    public List<BlogsEntry> findByG_U_S(long groupId, long userId, int status,
4412        int start, int end, OrderByComparator orderByComparator)
4413        throws SystemException {
4414        Object[] finderArgs = new Object[] {
4415                new Long(groupId), new Long(userId), new Integer(status),
4416                
4417                String.valueOf(start), String.valueOf(end),
4418                String.valueOf(orderByComparator)
4419            };
4420
4421        List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_U_S,
4422                finderArgs, this);
4423
4424        if (list == null) {
4425            Session session = null;
4426
4427            try {
4428                session = openSession();
4429
4430                StringBundler query = null;
4431
4432                if (orderByComparator != null) {
4433                    query = new StringBundler(5 +
4434                            (orderByComparator.getOrderByFields().length * 3));
4435                }
4436                else {
4437                    query = new StringBundler(5);
4438                }
4439
4440                query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
4441
4442                query.append(_FINDER_COLUMN_G_U_S_GROUPID_2);
4443
4444                query.append(_FINDER_COLUMN_G_U_S_USERID_2);
4445
4446                query.append(_FINDER_COLUMN_G_U_S_STATUS_2);
4447
4448                if (orderByComparator != null) {
4449                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
4450                        orderByComparator);
4451                }
4452
4453                else {
4454                    query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
4455                }
4456
4457                String sql = query.toString();
4458
4459                Query q = session.createQuery(sql);
4460
4461                QueryPos qPos = QueryPos.getInstance(q);
4462
4463                qPos.add(groupId);
4464
4465                qPos.add(userId);
4466
4467                qPos.add(status);
4468
4469                list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start,
4470                        end);
4471            }
4472            catch (Exception e) {
4473                throw processException(e);
4474            }
4475            finally {
4476                if (list == null) {
4477                    list = new ArrayList<BlogsEntry>();
4478                }
4479
4480                cacheResult(list);
4481
4482                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_U_S,
4483                    finderArgs, list);
4484
4485                closeSession(session);
4486            }
4487        }
4488
4489        return list;
4490    }
4491
4492    public BlogsEntry findByG_U_S_First(long groupId, long userId, int status,
4493        OrderByComparator orderByComparator)
4494        throws NoSuchEntryException, SystemException {
4495        List<BlogsEntry> list = findByG_U_S(groupId, userId, status, 0, 1,
4496                orderByComparator);
4497
4498        if (list.isEmpty()) {
4499            StringBundler msg = new StringBundler(8);
4500
4501            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
4502
4503            msg.append("groupId=");
4504            msg.append(groupId);
4505
4506            msg.append(", userId=");
4507            msg.append(userId);
4508
4509            msg.append(", status=");
4510            msg.append(status);
4511
4512            msg.append(StringPool.CLOSE_CURLY_BRACE);
4513
4514            throw new NoSuchEntryException(msg.toString());
4515        }
4516        else {
4517            return list.get(0);
4518        }
4519    }
4520
4521    public BlogsEntry findByG_U_S_Last(long groupId, long userId, int status,
4522        OrderByComparator orderByComparator)
4523        throws NoSuchEntryException, SystemException {
4524        int count = countByG_U_S(groupId, userId, status);
4525
4526        List<BlogsEntry> list = findByG_U_S(groupId, userId, status, count - 1,
4527                count, orderByComparator);
4528
4529        if (list.isEmpty()) {
4530            StringBundler msg = new StringBundler(8);
4531
4532            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
4533
4534            msg.append("groupId=");
4535            msg.append(groupId);
4536
4537            msg.append(", userId=");
4538            msg.append(userId);
4539
4540            msg.append(", status=");
4541            msg.append(status);
4542
4543            msg.append(StringPool.CLOSE_CURLY_BRACE);
4544
4545            throw new NoSuchEntryException(msg.toString());
4546        }
4547        else {
4548            return list.get(0);
4549        }
4550    }
4551
4552    public BlogsEntry[] findByG_U_S_PrevAndNext(long entryId, long groupId,
4553        long userId, int status, OrderByComparator orderByComparator)
4554        throws NoSuchEntryException, SystemException {
4555        BlogsEntry blogsEntry = findByPrimaryKey(entryId);
4556
4557        Session session = null;
4558
4559        try {
4560            session = openSession();
4561
4562            BlogsEntry[] array = new BlogsEntryImpl[3];
4563
4564            array[0] = getByG_U_S_PrevAndNext(session, blogsEntry, groupId,
4565                    userId, status, orderByComparator, true);
4566
4567            array[1] = blogsEntry;
4568
4569            array[2] = getByG_U_S_PrevAndNext(session, blogsEntry, groupId,
4570                    userId, status, orderByComparator, false);
4571
4572            return array;
4573        }
4574        catch (Exception e) {
4575            throw processException(e);
4576        }
4577        finally {
4578            closeSession(session);
4579        }
4580    }
4581
4582    protected BlogsEntry getByG_U_S_PrevAndNext(Session session,
4583        BlogsEntry blogsEntry, long groupId, long userId, int status,
4584        OrderByComparator orderByComparator, boolean previous) {
4585        StringBundler query = null;
4586
4587        if (orderByComparator != null) {
4588            query = new StringBundler(6 +
4589                    (orderByComparator.getOrderByFields().length * 6));
4590        }
4591        else {
4592            query = new StringBundler(3);
4593        }
4594
4595        query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
4596
4597        query.append(_FINDER_COLUMN_G_U_S_GROUPID_2);
4598
4599        query.append(_FINDER_COLUMN_G_U_S_USERID_2);
4600
4601        query.append(_FINDER_COLUMN_G_U_S_STATUS_2);
4602
4603        if (orderByComparator != null) {
4604            String[] orderByFields = orderByComparator.getOrderByFields();
4605
4606            if (orderByFields.length > 0) {
4607                query.append(WHERE_AND);
4608            }
4609
4610            for (int i = 0; i < orderByFields.length; i++) {
4611                query.append(_ORDER_BY_ENTITY_ALIAS);
4612                query.append(orderByFields[i]);
4613
4614                if ((i + 1) < orderByFields.length) {
4615                    if (orderByComparator.isAscending() ^ previous) {
4616                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
4617                    }
4618                    else {
4619                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
4620                    }
4621                }
4622                else {
4623                    if (orderByComparator.isAscending() ^ previous) {
4624                        query.append(WHERE_GREATER_THAN);
4625                    }
4626                    else {
4627                        query.append(WHERE_LESSER_THAN);
4628                    }
4629                }
4630            }
4631
4632            query.append(ORDER_BY_CLAUSE);
4633
4634            for (int i = 0; i < orderByFields.length; i++) {
4635                query.append(_ORDER_BY_ENTITY_ALIAS);
4636                query.append(orderByFields[i]);
4637
4638                if ((i + 1) < orderByFields.length) {
4639                    if (orderByComparator.isAscending() ^ previous) {
4640                        query.append(ORDER_BY_ASC_HAS_NEXT);
4641                    }
4642                    else {
4643                        query.append(ORDER_BY_DESC_HAS_NEXT);
4644                    }
4645                }
4646                else {
4647                    if (orderByComparator.isAscending() ^ previous) {
4648                        query.append(ORDER_BY_ASC);
4649                    }
4650                    else {
4651                        query.append(ORDER_BY_DESC);
4652                    }
4653                }
4654            }
4655        }
4656
4657        else {
4658            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
4659        }
4660
4661        String sql = query.toString();
4662
4663        Query q = session.createQuery(sql);
4664
4665        q.setFirstResult(0);
4666        q.setMaxResults(2);
4667
4668        QueryPos qPos = QueryPos.getInstance(q);
4669
4670        qPos.add(groupId);
4671
4672        qPos.add(userId);
4673
4674        qPos.add(status);
4675
4676        if (orderByComparator != null) {
4677            Object[] values = orderByComparator.getOrderByValues(blogsEntry);
4678
4679            for (Object value : values) {
4680                qPos.add(value);
4681            }
4682        }
4683
4684        List<BlogsEntry> list = q.list();
4685
4686        if (list.size() == 2) {
4687            return list.get(1);
4688        }
4689        else {
4690            return null;
4691        }
4692    }
4693
4694    public List<BlogsEntry> filterFindByG_U_S(long groupId, long userId,
4695        int status) throws SystemException {
4696        return filterFindByG_U_S(groupId, userId, status, QueryUtil.ALL_POS,
4697            QueryUtil.ALL_POS, null);
4698    }
4699
4700    public List<BlogsEntry> filterFindByG_U_S(long groupId, long userId,
4701        int status, int start, int end) throws SystemException {
4702        return filterFindByG_U_S(groupId, userId, status, start, end, null);
4703    }
4704
4705    public List<BlogsEntry> filterFindByG_U_S(long groupId, long userId,
4706        int status, int start, int end, OrderByComparator orderByComparator)
4707        throws SystemException {
4708        if (!InlineSQLHelperUtil.isEnabled(groupId)) {
4709            return findByG_U_S(groupId, userId, status, start, end,
4710                orderByComparator);
4711        }
4712
4713        Session session = null;
4714
4715        try {
4716            session = openSession();
4717
4718            StringBundler query = null;
4719
4720            if (orderByComparator != null) {
4721                query = new StringBundler(5 +
4722                        (orderByComparator.getOrderByFields().length * 3));
4723            }
4724            else {
4725                query = new StringBundler(5);
4726            }
4727
4728            query.append(_FILTER_SQL_SELECT_BLOGSENTRY_WHERE);
4729
4730            query.append(_FINDER_COLUMN_G_U_S_GROUPID_2);
4731
4732            query.append(_FINDER_COLUMN_G_U_S_USERID_2);
4733
4734            query.append(_FINDER_COLUMN_G_U_S_STATUS_2);
4735
4736            if (orderByComparator != null) {
4737                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
4738                    orderByComparator);
4739            }
4740
4741            else {
4742                query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
4743            }
4744
4745            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
4746                    BlogsEntry.class.getName(), _FILTER_COLUMN_ENTRYID,
4747                    _FILTER_COLUMN_USERID, groupId);
4748
4749            SQLQuery q = session.createSQLQuery(sql);
4750
4751            q.addEntity(_FILTER_ENTITY_ALIAS, BlogsEntryImpl.class);
4752
4753            QueryPos qPos = QueryPos.getInstance(q);
4754
4755            qPos.add(groupId);
4756
4757            qPos.add(userId);
4758
4759            qPos.add(status);
4760
4761            return (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start, end);
4762        }
4763        catch (Exception e) {
4764            throw processException(e);
4765        }
4766        finally {
4767            closeSession(session);
4768        }
4769    }
4770
4771    public List<BlogsEntry> findByG_D_S(long groupId, Date displayDate,
4772        int status) throws SystemException {
4773        return findByG_D_S(groupId, displayDate, status, QueryUtil.ALL_POS,
4774            QueryUtil.ALL_POS, null);
4775    }
4776
4777    public List<BlogsEntry> findByG_D_S(long groupId, Date displayDate,
4778        int status, int start, int end) throws SystemException {
4779        return findByG_D_S(groupId, displayDate, status, start, end, null);
4780    }
4781
4782    public List<BlogsEntry> findByG_D_S(long groupId, Date displayDate,
4783        int status, int start, int end, OrderByComparator orderByComparator)
4784        throws SystemException {
4785        Object[] finderArgs = new Object[] {
4786                new Long(groupId),
4787                
4788                displayDate, new Integer(status),
4789                
4790                String.valueOf(start), String.valueOf(end),
4791                String.valueOf(orderByComparator)
4792            };
4793
4794        List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_D_S,
4795                finderArgs, this);
4796
4797        if (list == null) {
4798            Session session = null;
4799
4800            try {
4801                session = openSession();
4802
4803                StringBundler query = null;
4804
4805                if (orderByComparator != null) {
4806                    query = new StringBundler(5 +
4807                            (orderByComparator.getOrderByFields().length * 3));
4808                }
4809                else {
4810                    query = new StringBundler(5);
4811                }
4812
4813                query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
4814
4815                query.append(_FINDER_COLUMN_G_D_S_GROUPID_2);
4816
4817                if (displayDate == null) {
4818                    query.append(_FINDER_COLUMN_G_D_S_DISPLAYDATE_1);
4819                }
4820                else {
4821                    query.append(_FINDER_COLUMN_G_D_S_DISPLAYDATE_2);
4822                }
4823
4824                query.append(_FINDER_COLUMN_G_D_S_STATUS_2);
4825
4826                if (orderByComparator != null) {
4827                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
4828                        orderByComparator);
4829                }
4830
4831                else {
4832                    query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
4833                }
4834
4835                String sql = query.toString();
4836
4837                Query q = session.createQuery(sql);
4838
4839                QueryPos qPos = QueryPos.getInstance(q);
4840
4841                qPos.add(groupId);
4842
4843                if (displayDate != null) {
4844                    qPos.add(CalendarUtil.getTimestamp(displayDate));
4845                }
4846
4847                qPos.add(status);
4848
4849                list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start,
4850                        end);
4851            }
4852            catch (Exception e) {
4853                throw processException(e);
4854            }
4855            finally {
4856                if (list == null) {
4857                    list = new ArrayList<BlogsEntry>();
4858                }
4859
4860                cacheResult(list);
4861
4862                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_D_S,
4863                    finderArgs, list);
4864
4865                closeSession(session);
4866            }
4867        }
4868
4869        return list;
4870    }
4871
4872    public BlogsEntry findByG_D_S_First(long groupId, Date displayDate,
4873        int status, OrderByComparator orderByComparator)
4874        throws NoSuchEntryException, SystemException {
4875        List<BlogsEntry> list = findByG_D_S(groupId, displayDate, status, 0, 1,
4876                orderByComparator);
4877
4878        if (list.isEmpty()) {
4879            StringBundler msg = new StringBundler(8);
4880
4881            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
4882
4883            msg.append("groupId=");
4884            msg.append(groupId);
4885
4886            msg.append(", displayDate=");
4887            msg.append(displayDate);
4888
4889            msg.append(", status=");
4890            msg.append(status);
4891
4892            msg.append(StringPool.CLOSE_CURLY_BRACE);
4893
4894            throw new NoSuchEntryException(msg.toString());
4895        }
4896        else {
4897            return list.get(0);
4898        }
4899    }
4900
4901    public BlogsEntry findByG_D_S_Last(long groupId, Date displayDate,
4902        int status, OrderByComparator orderByComparator)
4903        throws NoSuchEntryException, SystemException {
4904        int count = countByG_D_S(groupId, displayDate, status);
4905
4906        List<BlogsEntry> list = findByG_D_S(groupId, displayDate, status,
4907                count - 1, count, orderByComparator);
4908
4909        if (list.isEmpty()) {
4910            StringBundler msg = new StringBundler(8);
4911
4912            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
4913
4914            msg.append("groupId=");
4915            msg.append(groupId);
4916
4917            msg.append(", displayDate=");
4918            msg.append(displayDate);
4919
4920            msg.append(", status=");
4921            msg.append(status);
4922
4923            msg.append(StringPool.CLOSE_CURLY_BRACE);
4924
4925            throw new NoSuchEntryException(msg.toString());
4926        }
4927        else {
4928            return list.get(0);
4929        }
4930    }
4931
4932    public BlogsEntry[] findByG_D_S_PrevAndNext(long entryId, long groupId,
4933        Date displayDate, int status, OrderByComparator orderByComparator)
4934        throws NoSuchEntryException, SystemException {
4935        BlogsEntry blogsEntry = findByPrimaryKey(entryId);
4936
4937        Session session = null;
4938
4939        try {
4940            session = openSession();
4941
4942            BlogsEntry[] array = new BlogsEntryImpl[3];
4943
4944            array[0] = getByG_D_S_PrevAndNext(session, blogsEntry, groupId,
4945                    displayDate, status, orderByComparator, true);
4946
4947            array[1] = blogsEntry;
4948
4949            array[2] = getByG_D_S_PrevAndNext(session, blogsEntry, groupId,
4950                    displayDate, status, orderByComparator, false);
4951
4952            return array;
4953        }
4954        catch (Exception e) {
4955            throw processException(e);
4956        }
4957        finally {
4958            closeSession(session);
4959        }
4960    }
4961
4962    protected BlogsEntry getByG_D_S_PrevAndNext(Session session,
4963        BlogsEntry blogsEntry, long groupId, Date displayDate, int status,
4964        OrderByComparator orderByComparator, boolean previous) {
4965        StringBundler query = null;
4966
4967        if (orderByComparator != null) {
4968            query = new StringBundler(6 +
4969                    (orderByComparator.getOrderByFields().length * 6));
4970        }
4971        else {
4972            query = new StringBundler(3);
4973        }
4974
4975        query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
4976
4977        query.append(_FINDER_COLUMN_G_D_S_GROUPID_2);
4978
4979        if (displayDate == null) {
4980            query.append(_FINDER_COLUMN_G_D_S_DISPLAYDATE_1);
4981        }
4982        else {
4983            query.append(_FINDER_COLUMN_G_D_S_DISPLAYDATE_2);
4984        }
4985
4986        query.append(_FINDER_COLUMN_G_D_S_STATUS_2);
4987
4988        if (orderByComparator != null) {
4989            String[] orderByFields = orderByComparator.getOrderByFields();
4990
4991            if (orderByFields.length > 0) {
4992                query.append(WHERE_AND);
4993            }
4994
4995            for (int i = 0; i < orderByFields.length; i++) {
4996                query.append(_ORDER_BY_ENTITY_ALIAS);
4997                query.append(orderByFields[i]);
4998
4999                if ((i + 1) < orderByFields.length) {
5000                    if (orderByComparator.isAscending() ^ previous) {
5001                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
5002                    }
5003                    else {
5004                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
5005                    }
5006                }
5007                else {
5008                    if (orderByComparator.isAscending() ^ previous) {
5009                        query.append(WHERE_GREATER_THAN);
5010                    }
5011                    else {
5012                        query.append(WHERE_LESSER_THAN);
5013                    }
5014                }
5015            }
5016
5017            query.append(ORDER_BY_CLAUSE);
5018
5019            for (int i = 0; i < orderByFields.length; i++) {
5020                query.append(_ORDER_BY_ENTITY_ALIAS);
5021                query.append(orderByFields[i]);
5022
5023                if ((i + 1) < orderByFields.length) {
5024                    if (orderByComparator.isAscending() ^ previous) {
5025                        query.append(ORDER_BY_ASC_HAS_NEXT);
5026                    }
5027                    else {
5028                        query.append(ORDER_BY_DESC_HAS_NEXT);
5029                    }
5030                }
5031                else {
5032                    if (orderByComparator.isAscending() ^ previous) {
5033                        query.append(ORDER_BY_ASC);
5034                    }
5035                    else {
5036                        query.append(ORDER_BY_DESC);
5037                    }
5038                }
5039            }
5040        }
5041
5042        else {
5043            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
5044        }
5045
5046        String sql = query.toString();
5047
5048        Query q = session.createQuery(sql);
5049
5050        q.setFirstResult(0);
5051        q.setMaxResults(2);
5052
5053        QueryPos qPos = QueryPos.getInstance(q);
5054
5055        qPos.add(groupId);
5056
5057        if (displayDate != null) {
5058            qPos.add(CalendarUtil.getTimestamp(displayDate));
5059        }
5060
5061        qPos.add(status);
5062
5063        if (orderByComparator != null) {
5064            Object[] values = orderByComparator.getOrderByValues(blogsEntry);
5065
5066            for (Object value : values) {
5067                qPos.add(value);
5068            }
5069        }
5070
5071        List<BlogsEntry> list = q.list();
5072
5073        if (list.size() == 2) {
5074            return list.get(1);
5075        }
5076        else {
5077            return null;
5078        }
5079    }
5080
5081    public List<BlogsEntry> filterFindByG_D_S(long groupId, Date displayDate,
5082        int status) throws SystemException {
5083        return filterFindByG_D_S(groupId, displayDate, status,
5084            QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
5085    }
5086
5087    public List<BlogsEntry> filterFindByG_D_S(long groupId, Date displayDate,
5088        int status, int start, int end) throws SystemException {
5089        return filterFindByG_D_S(groupId, displayDate, status, start, end, null);
5090    }
5091
5092    public List<BlogsEntry> filterFindByG_D_S(long groupId, Date displayDate,
5093        int status, int start, int end, OrderByComparator orderByComparator)
5094        throws SystemException {
5095        if (!InlineSQLHelperUtil.isEnabled(groupId)) {
5096            return findByG_D_S(groupId, displayDate, status, start, end,
5097                orderByComparator);
5098        }
5099
5100        Session session = null;
5101
5102        try {
5103            session = openSession();
5104
5105            StringBundler query = null;
5106
5107            if (orderByComparator != null) {
5108                query = new StringBundler(5 +
5109                        (orderByComparator.getOrderByFields().length * 3));
5110            }
5111            else {
5112                query = new StringBundler(5);
5113            }
5114
5115            query.append(_FILTER_SQL_SELECT_BLOGSENTRY_WHERE);
5116
5117            query.append(_FINDER_COLUMN_G_D_S_GROUPID_2);
5118
5119            if (displayDate == null) {
5120                query.append(_FINDER_COLUMN_G_D_S_DISPLAYDATE_1);
5121            }
5122            else {
5123                query.append(_FINDER_COLUMN_G_D_S_DISPLAYDATE_2);
5124            }
5125
5126            query.append(_FINDER_COLUMN_G_D_S_STATUS_2);
5127
5128            if (orderByComparator != null) {
5129                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
5130                    orderByComparator);
5131            }
5132
5133            else {
5134                query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
5135            }
5136
5137            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
5138                    BlogsEntry.class.getName(), _FILTER_COLUMN_ENTRYID,
5139                    _FILTER_COLUMN_USERID, groupId);
5140
5141            SQLQuery q = session.createSQLQuery(sql);
5142
5143            q.addEntity(_FILTER_ENTITY_ALIAS, BlogsEntryImpl.class);
5144
5145            QueryPos qPos = QueryPos.getInstance(q);
5146
5147            qPos.add(groupId);
5148
5149            if (displayDate != null) {
5150                qPos.add(CalendarUtil.getTimestamp(displayDate));
5151            }
5152
5153            qPos.add(status);
5154
5155            return (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start, end);
5156        }
5157        catch (Exception e) {
5158            throw processException(e);
5159        }
5160        finally {
5161            closeSession(session);
5162        }
5163    }
5164
5165    public List<BlogsEntry> findByG_U_D_S(long groupId, long userId,
5166        Date displayDate, int status) throws SystemException {
5167        return findByG_U_D_S(groupId, userId, displayDate, status,
5168            QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
5169    }
5170
5171    public List<BlogsEntry> findByG_U_D_S(long groupId, long userId,
5172        Date displayDate, int status, int start, int end)
5173        throws SystemException {
5174        return findByG_U_D_S(groupId, userId, displayDate, status, start, end,
5175            null);
5176    }
5177
5178    public List<BlogsEntry> findByG_U_D_S(long groupId, long userId,
5179        Date displayDate, int status, int start, int end,
5180        OrderByComparator orderByComparator) throws SystemException {
5181        Object[] finderArgs = new Object[] {
5182                new Long(groupId), new Long(userId),
5183                
5184                displayDate, new Integer(status),
5185                
5186                String.valueOf(start), String.valueOf(end),
5187                String.valueOf(orderByComparator)
5188            };
5189
5190        List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_U_D_S,
5191                finderArgs, this);
5192
5193        if (list == null) {
5194            Session session = null;
5195
5196            try {
5197                session = openSession();
5198
5199                StringBundler query = null;
5200
5201                if (orderByComparator != null) {
5202                    query = new StringBundler(6 +
5203                            (orderByComparator.getOrderByFields().length * 3));
5204                }
5205                else {
5206                    query = new StringBundler(6);
5207                }
5208
5209                query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
5210
5211                query.append(_FINDER_COLUMN_G_U_D_S_GROUPID_2);
5212
5213                query.append(_FINDER_COLUMN_G_U_D_S_USERID_2);
5214
5215                if (displayDate == null) {
5216                    query.append(_FINDER_COLUMN_G_U_D_S_DISPLAYDATE_1);
5217                }
5218                else {
5219                    query.append(_FINDER_COLUMN_G_U_D_S_DISPLAYDATE_2);
5220                }
5221
5222                query.append(_FINDER_COLUMN_G_U_D_S_STATUS_2);
5223
5224                if (orderByComparator != null) {
5225                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
5226                        orderByComparator);
5227                }
5228
5229                else {
5230                    query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
5231                }
5232
5233                String sql = query.toString();
5234
5235                Query q = session.createQuery(sql);
5236
5237                QueryPos qPos = QueryPos.getInstance(q);
5238
5239                qPos.add(groupId);
5240
5241                qPos.add(userId);
5242
5243                if (displayDate != null) {
5244                    qPos.add(CalendarUtil.getTimestamp(displayDate));
5245                }
5246
5247                qPos.add(status);
5248
5249                list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start,
5250                        end);
5251            }
5252            catch (Exception e) {
5253                throw processException(e);
5254            }
5255            finally {
5256                if (list == null) {
5257                    list = new ArrayList<BlogsEntry>();
5258                }
5259
5260                cacheResult(list);
5261
5262                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_U_D_S,
5263                    finderArgs, list);
5264
5265                closeSession(session);
5266            }
5267        }
5268
5269        return list;
5270    }
5271
5272    public BlogsEntry findByG_U_D_S_First(long groupId, long userId,
5273        Date displayDate, int status, OrderByComparator orderByComparator)
5274        throws NoSuchEntryException, SystemException {
5275        List<BlogsEntry> list = findByG_U_D_S(groupId, userId, displayDate,
5276                status, 0, 1, orderByComparator);
5277
5278        if (list.isEmpty()) {
5279            StringBundler msg = new StringBundler(10);
5280
5281            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
5282
5283            msg.append("groupId=");
5284            msg.append(groupId);
5285
5286            msg.append(", userId=");
5287            msg.append(userId);
5288
5289            msg.append(", displayDate=");
5290            msg.append(displayDate);
5291
5292            msg.append(", status=");
5293            msg.append(status);
5294
5295            msg.append(StringPool.CLOSE_CURLY_BRACE);
5296
5297            throw new NoSuchEntryException(msg.toString());
5298        }
5299        else {
5300            return list.get(0);
5301        }
5302    }
5303
5304    public BlogsEntry findByG_U_D_S_Last(long groupId, long userId,
5305        Date displayDate, int status, OrderByComparator orderByComparator)
5306        throws NoSuchEntryException, SystemException {
5307        int count = countByG_U_D_S(groupId, userId, displayDate, status);
5308
5309        List<BlogsEntry> list = findByG_U_D_S(groupId, userId, displayDate,
5310                status, count - 1, count, orderByComparator);
5311
5312        if (list.isEmpty()) {
5313            StringBundler msg = new StringBundler(10);
5314
5315            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
5316
5317            msg.append("groupId=");
5318            msg.append(groupId);
5319
5320            msg.append(", userId=");
5321            msg.append(userId);
5322
5323            msg.append(", displayDate=");
5324            msg.append(displayDate);
5325
5326            msg.append(", status=");
5327            msg.append(status);
5328
5329            msg.append(StringPool.CLOSE_CURLY_BRACE);
5330
5331            throw new NoSuchEntryException(msg.toString());
5332        }
5333        else {
5334            return list.get(0);
5335        }
5336    }
5337
5338    public BlogsEntry[] findByG_U_D_S_PrevAndNext(long entryId, long groupId,
5339        long userId, Date displayDate, int status,
5340        OrderByComparator orderByComparator)
5341        throws NoSuchEntryException, SystemException {
5342        BlogsEntry blogsEntry = findByPrimaryKey(entryId);
5343
5344        Session session = null;
5345
5346        try {
5347            session = openSession();
5348
5349            BlogsEntry[] array = new BlogsEntryImpl[3];
5350
5351            array[0] = getByG_U_D_S_PrevAndNext(session, blogsEntry, groupId,
5352                    userId, displayDate, status, orderByComparator, true);
5353
5354            array[1] = blogsEntry;
5355
5356            array[2] = getByG_U_D_S_PrevAndNext(session, blogsEntry, groupId,
5357                    userId, displayDate, status, orderByComparator, false);
5358
5359            return array;
5360        }
5361        catch (Exception e) {
5362            throw processException(e);
5363        }
5364        finally {
5365            closeSession(session);
5366        }
5367    }
5368
5369    protected BlogsEntry getByG_U_D_S_PrevAndNext(Session session,
5370        BlogsEntry blogsEntry, long groupId, long userId, Date displayDate,
5371        int status, OrderByComparator orderByComparator, boolean previous) {
5372        StringBundler query = null;
5373
5374        if (orderByComparator != null) {
5375            query = new StringBundler(6 +
5376                    (orderByComparator.getOrderByFields().length * 6));
5377        }
5378        else {
5379            query = new StringBundler(3);
5380        }
5381
5382        query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
5383
5384        query.append(_FINDER_COLUMN_G_U_D_S_GROUPID_2);
5385
5386        query.append(_FINDER_COLUMN_G_U_D_S_USERID_2);
5387
5388        if (displayDate == null) {
5389            query.append(_FINDER_COLUMN_G_U_D_S_DISPLAYDATE_1);
5390        }
5391        else {
5392            query.append(_FINDER_COLUMN_G_U_D_S_DISPLAYDATE_2);
5393        }
5394
5395        query.append(_FINDER_COLUMN_G_U_D_S_STATUS_2);
5396
5397        if (orderByComparator != null) {
5398            String[] orderByFields = orderByComparator.getOrderByFields();
5399
5400            if (orderByFields.length > 0) {
5401                query.append(WHERE_AND);
5402            }
5403
5404            for (int i = 0; i < orderByFields.length; i++) {
5405                query.append(_ORDER_BY_ENTITY_ALIAS);
5406                query.append(orderByFields[i]);
5407
5408                if ((i + 1) < orderByFields.length) {
5409                    if (orderByComparator.isAscending() ^ previous) {
5410                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
5411                    }
5412                    else {
5413                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
5414                    }
5415                }
5416                else {
5417                    if (orderByComparator.isAscending() ^ previous) {
5418                        query.append(WHERE_GREATER_THAN);
5419                    }
5420                    else {
5421                        query.append(WHERE_LESSER_THAN);
5422                    }
5423                }
5424            }
5425
5426            query.append(ORDER_BY_CLAUSE);
5427
5428            for (int i = 0; i < orderByFields.length; i++) {
5429                query.append(_ORDER_BY_ENTITY_ALIAS);
5430                query.append(orderByFields[i]);
5431
5432                if ((i + 1) < orderByFields.length) {
5433                    if (orderByComparator.isAscending() ^ previous) {
5434                        query.append(ORDER_BY_ASC_HAS_NEXT);
5435                    }
5436                    else {
5437                        query.append(ORDER_BY_DESC_HAS_NEXT);
5438                    }
5439                }
5440                else {
5441                    if (orderByComparator.isAscending() ^ previous) {
5442                        query.append(ORDER_BY_ASC);
5443                    }
5444                    else {
5445                        query.append(ORDER_BY_DESC);
5446                    }
5447                }
5448            }
5449        }
5450
5451        else {
5452            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
5453        }
5454
5455        String sql = query.toString();
5456
5457        Query q = session.createQuery(sql);
5458
5459        q.setFirstResult(0);
5460        q.setMaxResults(2);
5461
5462        QueryPos qPos = QueryPos.getInstance(q);
5463
5464        qPos.add(groupId);
5465
5466        qPos.add(userId);
5467
5468        if (displayDate != null) {
5469            qPos.add(CalendarUtil.getTimestamp(displayDate));
5470        }
5471
5472        qPos.add(status);
5473
5474        if (orderByComparator != null) {
5475            Object[] values = orderByComparator.getOrderByValues(blogsEntry);
5476
5477            for (Object value : values) {
5478                qPos.add(value);
5479            }
5480        }
5481
5482        List<BlogsEntry> list = q.list();
5483
5484        if (list.size() == 2) {
5485            return list.get(1);
5486        }
5487        else {
5488            return null;
5489        }
5490    }
5491
5492    public List<BlogsEntry> filterFindByG_U_D_S(long groupId, long userId,
5493        Date displayDate, int status) throws SystemException {
5494        return filterFindByG_U_D_S(groupId, userId, displayDate, status,
5495            QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
5496    }
5497
5498    public List<BlogsEntry> filterFindByG_U_D_S(long groupId, long userId,
5499        Date displayDate, int status, int start, int end)
5500        throws SystemException {
5501        return filterFindByG_U_D_S(groupId, userId, displayDate, status, start,
5502            end, null);
5503    }
5504
5505    public List<BlogsEntry> filterFindByG_U_D_S(long groupId, long userId,
5506        Date displayDate, int status, int start, int end,
5507        OrderByComparator orderByComparator) throws SystemException {
5508        if (!InlineSQLHelperUtil.isEnabled(groupId)) {
5509            return findByG_U_D_S(groupId, userId, displayDate, status, start,
5510                end, orderByComparator);
5511        }
5512
5513        Session session = null;
5514
5515        try {
5516            session = openSession();
5517
5518            StringBundler query = null;
5519
5520            if (orderByComparator != null) {
5521                query = new StringBundler(6 +
5522                        (orderByComparator.getOrderByFields().length * 3));
5523            }
5524            else {
5525                query = new StringBundler(6);
5526            }
5527
5528            query.append(_FILTER_SQL_SELECT_BLOGSENTRY_WHERE);
5529
5530            query.append(_FINDER_COLUMN_G_U_D_S_GROUPID_2);
5531
5532            query.append(_FINDER_COLUMN_G_U_D_S_USERID_2);
5533
5534            if (displayDate == null) {
5535                query.append(_FINDER_COLUMN_G_U_D_S_DISPLAYDATE_1);
5536            }
5537            else {
5538                query.append(_FINDER_COLUMN_G_U_D_S_DISPLAYDATE_2);
5539            }
5540
5541            query.append(_FINDER_COLUMN_G_U_D_S_STATUS_2);
5542
5543            if (orderByComparator != null) {
5544                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
5545                    orderByComparator);
5546            }
5547
5548            else {
5549                query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
5550            }
5551
5552            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
5553                    BlogsEntry.class.getName(), _FILTER_COLUMN_ENTRYID,
5554                    _FILTER_COLUMN_USERID, groupId);
5555
5556            SQLQuery q = session.createSQLQuery(sql);
5557
5558            q.addEntity(_FILTER_ENTITY_ALIAS, BlogsEntryImpl.class);
5559
5560            QueryPos qPos = QueryPos.getInstance(q);
5561
5562            qPos.add(groupId);
5563
5564            qPos.add(userId);
5565
5566            if (displayDate != null) {
5567                qPos.add(CalendarUtil.getTimestamp(displayDate));
5568            }
5569
5570            qPos.add(status);
5571
5572            return (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start, end);
5573        }
5574        catch (Exception e) {
5575            throw processException(e);
5576        }
5577        finally {
5578            closeSession(session);
5579        }
5580    }
5581
5582    public List<BlogsEntry> findAll() throws SystemException {
5583        return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
5584    }
5585
5586    public List<BlogsEntry> findAll(int start, int end)
5587        throws SystemException {
5588        return findAll(start, end, null);
5589    }
5590
5591    public List<BlogsEntry> findAll(int start, int end,
5592        OrderByComparator orderByComparator) throws SystemException {
5593        Object[] finderArgs = new Object[] {
5594                String.valueOf(start), String.valueOf(end),
5595                String.valueOf(orderByComparator)
5596            };
5597
5598        List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
5599                finderArgs, this);
5600
5601        if (list == null) {
5602            Session session = null;
5603
5604            try {
5605                session = openSession();
5606
5607                StringBundler query = null;
5608                String sql = null;
5609
5610                if (orderByComparator != null) {
5611                    query = new StringBundler(2 +
5612                            (orderByComparator.getOrderByFields().length * 3));
5613
5614                    query.append(_SQL_SELECT_BLOGSENTRY);
5615
5616                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
5617                        orderByComparator);
5618
5619                    sql = query.toString();
5620                }
5621
5622                else {
5623                    sql = _SQL_SELECT_BLOGSENTRY.concat(BlogsEntryModelImpl.ORDER_BY_JPQL);
5624                }
5625
5626                Query q = session.createQuery(sql);
5627
5628                if (orderByComparator == null) {
5629                    list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(),
5630                            start, end, false);
5631
5632                    Collections.sort(list);
5633                }
5634                else {
5635                    list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(),
5636                            start, end);
5637                }
5638            }
5639            catch (Exception e) {
5640                throw processException(e);
5641            }
5642            finally {
5643                if (list == null) {
5644                    list = new ArrayList<BlogsEntry>();
5645                }
5646
5647                cacheResult(list);
5648
5649                FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
5650
5651                closeSession(session);
5652            }
5653        }
5654
5655        return list;
5656    }
5657
5658    public void removeByUuid(String uuid) throws SystemException {
5659        for (BlogsEntry blogsEntry : findByUuid(uuid)) {
5660            remove(blogsEntry);
5661        }
5662    }
5663
5664    public void removeByUUID_G(String uuid, long groupId)
5665        throws NoSuchEntryException, SystemException {
5666        BlogsEntry blogsEntry = findByUUID_G(uuid, groupId);
5667
5668        remove(blogsEntry);
5669    }
5670
5671    public void removeByGroupId(long groupId) throws SystemException {
5672        for (BlogsEntry blogsEntry : findByGroupId(groupId)) {
5673            remove(blogsEntry);
5674        }
5675    }
5676
5677    public void removeByCompanyId(long companyId) throws SystemException {
5678        for (BlogsEntry blogsEntry : findByCompanyId(companyId)) {
5679            remove(blogsEntry);
5680        }
5681    }
5682
5683    public void removeByC_U(long companyId, long userId)
5684        throws SystemException {
5685        for (BlogsEntry blogsEntry : findByC_U(companyId, userId)) {
5686            remove(blogsEntry);
5687        }
5688    }
5689
5690    public void removeByC_D(long companyId, Date displayDate)
5691        throws SystemException {
5692        for (BlogsEntry blogsEntry : findByC_D(companyId, displayDate)) {
5693            remove(blogsEntry);
5694        }
5695    }
5696
5697    public void removeByC_S(long companyId, int status)
5698        throws SystemException {
5699        for (BlogsEntry blogsEntry : findByC_S(companyId, status)) {
5700            remove(blogsEntry);
5701        }
5702    }
5703
5704    public void removeByG_UT(long groupId, String urlTitle)
5705        throws NoSuchEntryException, SystemException {
5706        BlogsEntry blogsEntry = findByG_UT(groupId, urlTitle);
5707
5708        remove(blogsEntry);
5709    }
5710
5711    public void removeByG_D(long groupId, Date displayDate)
5712        throws SystemException {
5713        for (BlogsEntry blogsEntry : findByG_D(groupId, displayDate)) {
5714            remove(blogsEntry);
5715        }
5716    }
5717
5718    public void removeByG_S(long groupId, int status) throws SystemException {
5719        for (BlogsEntry blogsEntry : findByG_S(groupId, status)) {
5720            remove(blogsEntry);
5721        }
5722    }
5723
5724    public void removeByC_U_S(long companyId, long userId, int status)
5725        throws SystemException {
5726        for (BlogsEntry blogsEntry : findByC_U_S(companyId, userId, status)) {
5727            remove(blogsEntry);
5728        }
5729    }
5730
5731    public void removeByC_D_S(long companyId, Date displayDate, int status)
5732        throws SystemException {
5733        for (BlogsEntry blogsEntry : findByC_D_S(companyId, displayDate, status)) {
5734            remove(blogsEntry);
5735        }
5736    }
5737
5738    public void removeByG_U_D(long groupId, long userId, Date displayDate)
5739        throws SystemException {
5740        for (BlogsEntry blogsEntry : findByG_U_D(groupId, userId, displayDate)) {
5741            remove(blogsEntry);
5742        }
5743    }
5744
5745    public void removeByG_U_S(long groupId, long userId, int status)
5746        throws SystemException {
5747        for (BlogsEntry blogsEntry : findByG_U_S(groupId, userId, status)) {
5748            remove(blogsEntry);
5749        }
5750    }
5751
5752    public void removeByG_D_S(long groupId, Date displayDate, int status)
5753        throws SystemException {
5754        for (BlogsEntry blogsEntry : findByG_D_S(groupId, displayDate, status)) {
5755            remove(blogsEntry);
5756        }
5757    }
5758
5759    public void removeByG_U_D_S(long groupId, long userId, Date displayDate,
5760        int status) throws SystemException {
5761        for (BlogsEntry blogsEntry : findByG_U_D_S(groupId, userId,
5762                displayDate, status)) {
5763            remove(blogsEntry);
5764        }
5765    }
5766
5767    public void removeAll() throws SystemException {
5768        for (BlogsEntry blogsEntry : findAll()) {
5769            remove(blogsEntry);
5770        }
5771    }
5772
5773    public int countByUuid(String uuid) throws SystemException {
5774        Object[] finderArgs = new Object[] { uuid };
5775
5776        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_UUID,
5777                finderArgs, this);
5778
5779        if (count == null) {
5780            Session session = null;
5781
5782            try {
5783                session = openSession();
5784
5785                StringBundler query = new StringBundler(2);
5786
5787                query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
5788
5789                if (uuid == null) {
5790                    query.append(_FINDER_COLUMN_UUID_UUID_1);
5791                }
5792                else {
5793                    if (uuid.equals(StringPool.BLANK)) {
5794                        query.append(_FINDER_COLUMN_UUID_UUID_3);
5795                    }
5796                    else {
5797                        query.append(_FINDER_COLUMN_UUID_UUID_2);
5798                    }
5799                }
5800
5801                String sql = query.toString();
5802
5803                Query q = session.createQuery(sql);
5804
5805                QueryPos qPos = QueryPos.getInstance(q);
5806
5807                if (uuid != null) {
5808                    qPos.add(uuid);
5809                }
5810
5811                count = (Long)q.uniqueResult();
5812            }
5813            catch (Exception e) {
5814                throw processException(e);
5815            }
5816            finally {
5817                if (count == null) {
5818                    count = Long.valueOf(0);
5819                }
5820
5821                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID,
5822                    finderArgs, count);
5823
5824                closeSession(session);
5825            }
5826        }
5827
5828        return count.intValue();
5829    }
5830
5831    public int countByUUID_G(String uuid, long groupId)
5832        throws SystemException {
5833        Object[] finderArgs = new Object[] { uuid, new Long(groupId) };
5834
5835        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_UUID_G,
5836                finderArgs, this);
5837
5838        if (count == null) {
5839            Session session = null;
5840
5841            try {
5842                session = openSession();
5843
5844                StringBundler query = new StringBundler(3);
5845
5846                query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
5847
5848                if (uuid == null) {
5849                    query.append(_FINDER_COLUMN_UUID_G_UUID_1);
5850                }
5851                else {
5852                    if (uuid.equals(StringPool.BLANK)) {
5853                        query.append(_FINDER_COLUMN_UUID_G_UUID_3);
5854                    }
5855                    else {
5856                        query.append(_FINDER_COLUMN_UUID_G_UUID_2);
5857                    }
5858                }
5859
5860                query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
5861
5862                String sql = query.toString();
5863
5864                Query q = session.createQuery(sql);
5865
5866                QueryPos qPos = QueryPos.getInstance(q);
5867
5868                if (uuid != null) {
5869                    qPos.add(uuid);
5870                }
5871
5872                qPos.add(groupId);
5873
5874                count = (Long)q.uniqueResult();
5875            }
5876            catch (Exception e) {
5877                throw processException(e);
5878            }
5879            finally {
5880                if (count == null) {
5881                    count = Long.valueOf(0);
5882                }
5883
5884                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID_G,
5885                    finderArgs, count);
5886
5887                closeSession(session);
5888            }
5889        }
5890
5891        return count.intValue();
5892    }
5893
5894    public int countByGroupId(long groupId) throws SystemException {
5895        Object[] finderArgs = new Object[] { new Long(groupId) };
5896
5897        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_GROUPID,
5898                finderArgs, this);
5899
5900        if (count == null) {
5901            Session session = null;
5902
5903            try {
5904                session = openSession();
5905
5906                StringBundler query = new StringBundler(2);
5907
5908                query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
5909
5910                query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
5911
5912                String sql = query.toString();
5913
5914                Query q = session.createQuery(sql);
5915
5916                QueryPos qPos = QueryPos.getInstance(q);
5917
5918                qPos.add(groupId);
5919
5920                count = (Long)q.uniqueResult();
5921            }
5922            catch (Exception e) {
5923                throw processException(e);
5924            }
5925            finally {
5926                if (count == null) {
5927                    count = Long.valueOf(0);
5928                }
5929
5930                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_GROUPID,
5931                    finderArgs, count);
5932
5933                closeSession(session);
5934            }
5935        }
5936
5937        return count.intValue();
5938    }
5939
5940    public int filterCountByGroupId(long groupId) throws SystemException {
5941        if (!InlineSQLHelperUtil.isEnabled(groupId)) {
5942            return countByGroupId(groupId);
5943        }
5944
5945        Session session = null;
5946
5947        try {
5948            session = openSession();
5949
5950            StringBundler query = new StringBundler(2);
5951
5952            query.append(_FILTER_SQL_COUNT_BLOGSENTRY_WHERE);
5953
5954            query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
5955
5956            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
5957                    BlogsEntry.class.getName(), _FILTER_COLUMN_ENTRYID,
5958                    _FILTER_COLUMN_USERID, groupId);
5959
5960            SQLQuery q = session.createSQLQuery(sql);
5961
5962            q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
5963
5964            QueryPos qPos = QueryPos.getInstance(q);
5965
5966            qPos.add(groupId);
5967
5968            Long count = (Long)q.uniqueResult();
5969
5970            return count.intValue();
5971        }
5972        catch (Exception e) {
5973            throw processException(e);
5974        }
5975        finally {
5976            closeSession(session);
5977        }
5978    }
5979
5980    public int countByCompanyId(long companyId) throws SystemException {
5981        Object[] finderArgs = new Object[] { new Long(companyId) };
5982
5983        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_COMPANYID,
5984                finderArgs, this);
5985
5986        if (count == null) {
5987            Session session = null;
5988
5989            try {
5990                session = openSession();
5991
5992                StringBundler query = new StringBundler(2);
5993
5994                query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
5995
5996                query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
5997
5998                String sql = query.toString();
5999
6000                Query q = session.createQuery(sql);
6001
6002                QueryPos qPos = QueryPos.getInstance(q);
6003
6004                qPos.add(companyId);
6005
6006                count = (Long)q.uniqueResult();
6007            }
6008            catch (Exception e) {
6009                throw processException(e);
6010            }
6011            finally {
6012                if (count == null) {
6013                    count = Long.valueOf(0);
6014                }
6015
6016                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_COMPANYID,
6017                    finderArgs, count);
6018
6019                closeSession(session);
6020            }
6021        }
6022
6023        return count.intValue();
6024    }
6025
6026    public int countByC_U(long companyId, long userId)
6027        throws SystemException {
6028        Object[] finderArgs = new Object[] { new Long(companyId), new Long(userId) };
6029
6030        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_U,
6031                finderArgs, this);
6032
6033        if (count == null) {
6034            Session session = null;
6035
6036            try {
6037                session = openSession();
6038
6039                StringBundler query = new StringBundler(3);
6040
6041                query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
6042
6043                query.append(_FINDER_COLUMN_C_U_COMPANYID_2);
6044
6045                query.append(_FINDER_COLUMN_C_U_USERID_2);
6046
6047                String sql = query.toString();
6048
6049                Query q = session.createQuery(sql);
6050
6051                QueryPos qPos = QueryPos.getInstance(q);
6052
6053                qPos.add(companyId);
6054
6055                qPos.add(userId);
6056
6057                count = (Long)q.uniqueResult();
6058            }
6059            catch (Exception e) {
6060                throw processException(e);
6061            }
6062            finally {
6063                if (count == null) {
6064                    count = Long.valueOf(0);
6065                }
6066
6067                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_U, finderArgs,
6068                    count);
6069
6070                closeSession(session);
6071            }
6072        }
6073
6074        return count.intValue();
6075    }
6076
6077    public int countByC_D(long companyId, Date displayDate)
6078        throws SystemException {
6079        Object[] finderArgs = new Object[] { new Long(companyId), displayDate };
6080
6081        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_D,
6082                finderArgs, this);
6083
6084        if (count == null) {
6085            Session session = null;
6086
6087            try {
6088                session = openSession();
6089
6090                StringBundler query = new StringBundler(3);
6091
6092                query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
6093
6094                query.append(_FINDER_COLUMN_C_D_COMPANYID_2);
6095
6096                if (displayDate == null) {
6097                    query.append(_FINDER_COLUMN_C_D_DISPLAYDATE_1);
6098                }
6099                else {
6100                    query.append(_FINDER_COLUMN_C_D_DISPLAYDATE_2);
6101                }
6102
6103                String sql = query.toString();
6104
6105                Query q = session.createQuery(sql);
6106
6107                QueryPos qPos = QueryPos.getInstance(q);
6108
6109                qPos.add(companyId);
6110
6111                if (displayDate != null) {
6112                    qPos.add(CalendarUtil.getTimestamp(displayDate));
6113                }
6114
6115                count = (Long)q.uniqueResult();
6116            }
6117            catch (Exception e) {
6118                throw processException(e);
6119            }
6120            finally {
6121                if (count == null) {
6122                    count = Long.valueOf(0);
6123                }
6124
6125                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_D, finderArgs,
6126                    count);
6127
6128                closeSession(session);
6129            }
6130        }
6131
6132        return count.intValue();
6133    }
6134
6135    public int countByC_S(long companyId, int status) throws SystemException {
6136        Object[] finderArgs = new Object[] {
6137                new Long(companyId), new Integer(status)
6138            };
6139
6140        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_S,
6141                finderArgs, this);
6142
6143        if (count == null) {
6144            Session session = null;
6145
6146            try {
6147                session = openSession();
6148
6149                StringBundler query = new StringBundler(3);
6150
6151                query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
6152
6153                query.append(_FINDER_COLUMN_C_S_COMPANYID_2);
6154
6155                query.append(_FINDER_COLUMN_C_S_STATUS_2);
6156
6157                String sql = query.toString();
6158
6159                Query q = session.createQuery(sql);
6160
6161                QueryPos qPos = QueryPos.getInstance(q);
6162
6163                qPos.add(companyId);
6164
6165                qPos.add(status);
6166
6167                count = (Long)q.uniqueResult();
6168            }
6169            catch (Exception e) {
6170                throw processException(e);
6171            }
6172            finally {
6173                if (count == null) {
6174                    count = Long.valueOf(0);
6175                }
6176
6177                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_S, finderArgs,
6178                    count);
6179
6180                closeSession(session);
6181            }
6182        }
6183
6184        return count.intValue();
6185    }
6186
6187    public int countByG_UT(long groupId, String urlTitle)
6188        throws SystemException {
6189        Object[] finderArgs = new Object[] { new Long(groupId), urlTitle };
6190
6191        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_UT,
6192                finderArgs, this);
6193
6194        if (count == null) {
6195            Session session = null;
6196
6197            try {
6198                session = openSession();
6199
6200                StringBundler query = new StringBundler(3);
6201
6202                query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
6203
6204                query.append(_FINDER_COLUMN_G_UT_GROUPID_2);
6205
6206                if (urlTitle == null) {
6207                    query.append(_FINDER_COLUMN_G_UT_URLTITLE_1);
6208                }
6209                else {
6210                    if (urlTitle.equals(StringPool.BLANK)) {
6211                        query.append(_FINDER_COLUMN_G_UT_URLTITLE_3);
6212                    }
6213                    else {
6214                        query.append(_FINDER_COLUMN_G_UT_URLTITLE_2);
6215                    }
6216                }
6217
6218                String sql = query.toString();
6219
6220                Query q = session.createQuery(sql);
6221
6222                QueryPos qPos = QueryPos.getInstance(q);
6223
6224                qPos.add(groupId);
6225
6226                if (urlTitle != null) {
6227                    qPos.add(urlTitle);
6228                }
6229
6230                count = (Long)q.uniqueResult();
6231            }
6232            catch (Exception e) {
6233                throw processException(e);
6234            }
6235            finally {
6236                if (count == null) {
6237                    count = Long.valueOf(0);
6238                }
6239
6240                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_UT,
6241                    finderArgs, count);
6242
6243                closeSession(session);
6244            }
6245        }
6246
6247        return count.intValue();
6248    }
6249
6250    public int filterCountByG_UT(long groupId, String urlTitle)
6251        throws SystemException {
6252        if (!InlineSQLHelperUtil.isEnabled(groupId)) {
6253            return countByG_UT(groupId, urlTitle);
6254        }
6255
6256        Session session = null;
6257
6258        try {
6259            session = openSession();
6260
6261            StringBundler query = new StringBundler(3);
6262
6263            query.append(_FILTER_SQL_COUNT_BLOGSENTRY_WHERE);
6264
6265            query.append(_FINDER_COLUMN_G_UT_GROUPID_2);
6266
6267            if (urlTitle == null) {
6268                query.append(_FINDER_COLUMN_G_UT_URLTITLE_1);
6269            }
6270            else {
6271                if (urlTitle.equals(StringPool.BLANK)) {
6272                    query.append(_FINDER_COLUMN_G_UT_URLTITLE_3);
6273                }
6274                else {
6275                    query.append(_FINDER_COLUMN_G_UT_URLTITLE_2);
6276                }
6277            }
6278
6279            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
6280                    BlogsEntry.class.getName(), _FILTER_COLUMN_ENTRYID,
6281                    _FILTER_COLUMN_USERID, groupId);
6282
6283            SQLQuery q = session.createSQLQuery(sql);
6284
6285            q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
6286
6287            QueryPos qPos = QueryPos.getInstance(q);
6288
6289            qPos.add(groupId);
6290
6291            if (urlTitle != null) {
6292                qPos.add(urlTitle);
6293            }
6294
6295            Long count = (Long)q.uniqueResult();
6296
6297            return count.intValue();
6298        }
6299        catch (Exception e) {
6300            throw processException(e);
6301        }
6302        finally {
6303            closeSession(session);
6304        }
6305    }
6306
6307    public int countByG_D(long groupId, Date displayDate)
6308        throws SystemException {
6309        Object[] finderArgs = new Object[] { new Long(groupId), displayDate };
6310
6311        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_D,
6312                finderArgs, this);
6313
6314        if (count == null) {
6315            Session session = null;
6316
6317            try {
6318                session = openSession();
6319
6320                StringBundler query = new StringBundler(3);
6321
6322                query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
6323
6324                query.append(_FINDER_COLUMN_G_D_GROUPID_2);
6325
6326                if (displayDate == null) {
6327                    query.append(_FINDER_COLUMN_G_D_DISPLAYDATE_1);
6328                }
6329                else {
6330                    query.append(_FINDER_COLUMN_G_D_DISPLAYDATE_2);
6331                }
6332
6333                String sql = query.toString();
6334
6335                Query q = session.createQuery(sql);
6336
6337                QueryPos qPos = QueryPos.getInstance(q);
6338
6339                qPos.add(groupId);
6340
6341                if (displayDate != null) {
6342                    qPos.add(CalendarUtil.getTimestamp(displayDate));
6343                }
6344
6345                count = (Long)q.uniqueResult();
6346            }
6347            catch (Exception e) {
6348                throw processException(e);
6349            }
6350            finally {
6351                if (count == null) {
6352                    count = Long.valueOf(0);
6353                }
6354
6355                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_D, finderArgs,
6356                    count);
6357
6358                closeSession(session);
6359            }
6360        }
6361
6362        return count.intValue();
6363    }
6364
6365    public int filterCountByG_D(long groupId, Date displayDate)
6366        throws SystemException {
6367        if (!InlineSQLHelperUtil.isEnabled(groupId)) {
6368            return countByG_D(groupId, displayDate);
6369        }
6370
6371        Session session = null;
6372
6373        try {
6374            session = openSession();
6375
6376            StringBundler query = new StringBundler(3);
6377
6378            query.append(_FILTER_SQL_COUNT_BLOGSENTRY_WHERE);
6379
6380            query.append(_FINDER_COLUMN_G_D_GROUPID_2);
6381
6382            if (displayDate == null) {
6383                query.append(_FINDER_COLUMN_G_D_DISPLAYDATE_1);
6384            }
6385            else {
6386                query.append(_FINDER_COLUMN_G_D_DISPLAYDATE_2);
6387            }
6388
6389            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
6390                    BlogsEntry.class.getName(), _FILTER_COLUMN_ENTRYID,
6391                    _FILTER_COLUMN_USERID, groupId);
6392
6393            SQLQuery q = session.createSQLQuery(sql);
6394
6395            q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
6396
6397            QueryPos qPos = QueryPos.getInstance(q);
6398
6399            qPos.add(groupId);
6400
6401            if (displayDate != null) {
6402                qPos.add(CalendarUtil.getTimestamp(displayDate));
6403            }
6404
6405            Long count = (Long)q.uniqueResult();
6406
6407            return count.intValue();
6408        }
6409        catch (Exception e) {
6410            throw processException(e);
6411        }
6412        finally {
6413            closeSession(session);
6414        }
6415    }
6416
6417    public int countByG_S(long groupId, int status) throws SystemException {
6418        Object[] finderArgs = new Object[] {
6419                new Long(groupId), new Integer(status)
6420            };
6421
6422        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_S,
6423                finderArgs, this);
6424
6425        if (count == null) {
6426            Session session = null;
6427
6428            try {
6429                session = openSession();
6430
6431                StringBundler query = new StringBundler(3);
6432
6433                query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
6434
6435                query.append(_FINDER_COLUMN_G_S_GROUPID_2);
6436
6437                query.append(_FINDER_COLUMN_G_S_STATUS_2);
6438
6439                String sql = query.toString();
6440
6441                Query q = session.createQuery(sql);
6442
6443                QueryPos qPos = QueryPos.getInstance(q);
6444
6445                qPos.add(groupId);
6446
6447                qPos.add(status);
6448
6449                count = (Long)q.uniqueResult();
6450            }
6451            catch (Exception e) {
6452                throw processException(e);
6453            }
6454            finally {
6455                if (count == null) {
6456                    count = Long.valueOf(0);
6457                }
6458
6459                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_S, finderArgs,
6460                    count);
6461
6462                closeSession(session);
6463            }
6464        }
6465
6466        return count.intValue();
6467    }
6468
6469    public int filterCountByG_S(long groupId, int status)
6470        throws SystemException {
6471        if (!InlineSQLHelperUtil.isEnabled(groupId)) {
6472            return countByG_S(groupId, status);
6473        }
6474
6475        Session session = null;
6476
6477        try {
6478            session = openSession();
6479
6480            StringBundler query = new StringBundler(3);
6481
6482            query.append(_FILTER_SQL_COUNT_BLOGSENTRY_WHERE);
6483
6484            query.append(_FINDER_COLUMN_G_S_GROUPID_2);
6485
6486            query.append(_FINDER_COLUMN_G_S_STATUS_2);
6487
6488            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
6489                    BlogsEntry.class.getName(), _FILTER_COLUMN_ENTRYID,
6490                    _FILTER_COLUMN_USERID, groupId);
6491
6492            SQLQuery q = session.createSQLQuery(sql);
6493
6494            q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
6495
6496            QueryPos qPos = QueryPos.getInstance(q);
6497
6498            qPos.add(groupId);
6499
6500            qPos.add(status);
6501
6502            Long count = (Long)q.uniqueResult();
6503
6504            return count.intValue();
6505        }
6506        catch (Exception e) {
6507            throw processException(e);
6508        }
6509        finally {
6510            closeSession(session);
6511        }
6512    }
6513
6514    public int countByC_U_S(long companyId, long userId, int status)
6515        throws SystemException {
6516        Object[] finderArgs = new Object[] {
6517                new Long(companyId), new Long(userId), new Integer(status)
6518            };
6519
6520        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_U_S,
6521                finderArgs, this);
6522
6523        if (count == null) {
6524            Session session = null;
6525
6526            try {
6527                session = openSession();
6528
6529                StringBundler query = new StringBundler(4);
6530
6531                query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
6532
6533                query.append(_FINDER_COLUMN_C_U_S_COMPANYID_2);
6534
6535                query.append(_FINDER_COLUMN_C_U_S_USERID_2);
6536
6537                query.append(_FINDER_COLUMN_C_U_S_STATUS_2);
6538
6539                String sql = query.toString();
6540
6541                Query q = session.createQuery(sql);
6542
6543                QueryPos qPos = QueryPos.getInstance(q);
6544
6545                qPos.add(companyId);
6546
6547                qPos.add(userId);
6548
6549                qPos.add(status);
6550
6551                count = (Long)q.uniqueResult();
6552            }
6553            catch (Exception e) {
6554                throw processException(e);
6555            }
6556            finally {
6557                if (count == null) {
6558                    count = Long.valueOf(0);
6559                }
6560
6561                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_U_S,
6562                    finderArgs, count);
6563
6564                closeSession(session);
6565            }
6566        }
6567
6568        return count.intValue();
6569    }
6570
6571    public int countByC_D_S(long companyId, Date displayDate, int status)
6572        throws SystemException {
6573        Object[] finderArgs = new Object[] {
6574                new Long(companyId),
6575                
6576                displayDate, new Integer(status)
6577            };
6578
6579        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_D_S,
6580                finderArgs, this);
6581
6582        if (count == null) {
6583            Session session = null;
6584
6585            try {
6586                session = openSession();
6587
6588                StringBundler query = new StringBundler(4);
6589
6590                query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
6591
6592                query.append(_FINDER_COLUMN_C_D_S_COMPANYID_2);
6593
6594                if (displayDate == null) {
6595                    query.append(_FINDER_COLUMN_C_D_S_DISPLAYDATE_1);
6596                }
6597                else {
6598                    query.append(_FINDER_COLUMN_C_D_S_DISPLAYDATE_2);
6599                }
6600
6601                query.append(_FINDER_COLUMN_C_D_S_STATUS_2);
6602
6603                String sql = query.toString();
6604
6605                Query q = session.createQuery(sql);
6606
6607                QueryPos qPos = QueryPos.getInstance(q);
6608
6609                qPos.add(companyId);
6610
6611                if (displayDate != null) {
6612                    qPos.add(CalendarUtil.getTimestamp(displayDate));
6613                }
6614
6615                qPos.add(status);
6616
6617                count = (Long)q.uniqueResult();
6618            }
6619            catch (Exception e) {
6620                throw processException(e);
6621            }
6622            finally {
6623                if (count == null) {
6624                    count = Long.valueOf(0);
6625                }
6626
6627                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_D_S,
6628                    finderArgs, count);
6629
6630                closeSession(session);
6631            }
6632        }
6633
6634        return count.intValue();
6635    }
6636
6637    public int countByG_U_D(long groupId, long userId, Date displayDate)
6638        throws SystemException {
6639        Object[] finderArgs = new Object[] {
6640                new Long(groupId), new Long(userId),
6641                
6642                displayDate
6643            };
6644
6645        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_U_D,
6646                finderArgs, this);
6647
6648        if (count == null) {
6649            Session session = null;
6650
6651            try {
6652                session = openSession();
6653
6654                StringBundler query = new StringBundler(4);
6655
6656                query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
6657
6658                query.append(_FINDER_COLUMN_G_U_D_GROUPID_2);
6659
6660                query.append(_FINDER_COLUMN_G_U_D_USERID_2);
6661
6662                if (displayDate == null) {
6663                    query.append(_FINDER_COLUMN_G_U_D_DISPLAYDATE_1);
6664                }
6665                else {
6666                    query.append(_FINDER_COLUMN_G_U_D_DISPLAYDATE_2);
6667                }
6668
6669                String sql = query.toString();
6670
6671                Query q = session.createQuery(sql);
6672
6673                QueryPos qPos = QueryPos.getInstance(q);
6674
6675                qPos.add(groupId);
6676
6677                qPos.add(userId);
6678
6679                if (displayDate != null) {
6680                    qPos.add(CalendarUtil.getTimestamp(displayDate));
6681                }
6682
6683                count = (Long)q.uniqueResult();
6684            }
6685            catch (Exception e) {
6686                throw processException(e);
6687            }
6688            finally {
6689                if (count == null) {
6690                    count = Long.valueOf(0);
6691                }
6692
6693                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_U_D,
6694                    finderArgs, count);
6695
6696                closeSession(session);
6697            }
6698        }
6699
6700        return count.intValue();
6701    }
6702
6703    public int filterCountByG_U_D(long groupId, long userId, Date displayDate)
6704        throws SystemException {
6705        if (!InlineSQLHelperUtil.isEnabled(groupId)) {
6706            return countByG_U_D(groupId, userId, displayDate);
6707        }
6708
6709        Session session = null;
6710
6711        try {
6712            session = openSession();
6713
6714            StringBundler query = new StringBundler(4);
6715
6716            query.append(_FILTER_SQL_COUNT_BLOGSENTRY_WHERE);
6717
6718            query.append(_FINDER_COLUMN_G_U_D_GROUPID_2);
6719
6720            query.append(_FINDER_COLUMN_G_U_D_USERID_2);
6721
6722            if (displayDate == null) {
6723                query.append(_FINDER_COLUMN_G_U_D_DISPLAYDATE_1);
6724            }
6725            else {
6726                query.append(_FINDER_COLUMN_G_U_D_DISPLAYDATE_2);
6727            }
6728
6729            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
6730                    BlogsEntry.class.getName(), _FILTER_COLUMN_ENTRYID,
6731                    _FILTER_COLUMN_USERID, groupId);
6732
6733            SQLQuery q = session.createSQLQuery(sql);
6734
6735            q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
6736
6737            QueryPos qPos = QueryPos.getInstance(q);
6738
6739            qPos.add(groupId);
6740
6741            qPos.add(userId);
6742
6743            if (displayDate != null) {
6744                qPos.add(CalendarUtil.getTimestamp(displayDate));
6745            }
6746
6747            Long count = (Long)q.uniqueResult();
6748
6749            return count.intValue();
6750        }
6751        catch (Exception e) {
6752            throw processException(e);
6753        }
6754        finally {
6755            closeSession(session);
6756        }
6757    }
6758
6759    public int countByG_U_S(long groupId, long userId, int status)
6760        throws SystemException {
6761        Object[] finderArgs = new Object[] {
6762                new Long(groupId), new Long(userId), new Integer(status)
6763            };
6764
6765        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_U_S,
6766                finderArgs, this);
6767
6768        if (count == null) {
6769            Session session = null;
6770
6771            try {
6772                session = openSession();
6773
6774                StringBundler query = new StringBundler(4);
6775
6776                query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
6777
6778                query.append(_FINDER_COLUMN_G_U_S_GROUPID_2);
6779
6780                query.append(_FINDER_COLUMN_G_U_S_USERID_2);
6781
6782                query.append(_FINDER_COLUMN_G_U_S_STATUS_2);
6783
6784                String sql = query.toString();
6785
6786                Query q = session.createQuery(sql);
6787
6788                QueryPos qPos = QueryPos.getInstance(q);
6789
6790                qPos.add(groupId);
6791
6792                qPos.add(userId);
6793
6794                qPos.add(status);
6795
6796                count = (Long)q.uniqueResult();
6797            }
6798            catch (Exception e) {
6799                throw processException(e);
6800            }
6801            finally {
6802                if (count == null) {
6803                    count = Long.valueOf(0);
6804                }
6805
6806                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_U_S,
6807                    finderArgs, count);
6808
6809                closeSession(session);
6810            }
6811        }
6812
6813        return count.intValue();
6814    }
6815
6816    public int filterCountByG_U_S(long groupId, long userId, int status)
6817        throws SystemException {
6818        if (!InlineSQLHelperUtil.isEnabled(groupId)) {
6819            return countByG_U_S(groupId, userId, status);
6820        }
6821
6822        Session session = null;
6823
6824        try {
6825            session = openSession();
6826
6827            StringBundler query = new StringBundler(4);
6828
6829            query.append(_FILTER_SQL_COUNT_BLOGSENTRY_WHERE);
6830
6831            query.append(_FINDER_COLUMN_G_U_S_GROUPID_2);
6832
6833            query.append(_FINDER_COLUMN_G_U_S_USERID_2);
6834
6835            query.append(_FINDER_COLUMN_G_U_S_STATUS_2);
6836
6837            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
6838                    BlogsEntry.class.getName(), _FILTER_COLUMN_ENTRYID,
6839                    _FILTER_COLUMN_USERID, groupId);
6840
6841            SQLQuery q = session.createSQLQuery(sql);
6842
6843            q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
6844
6845            QueryPos qPos = QueryPos.getInstance(q);
6846
6847            qPos.add(groupId);
6848
6849            qPos.add(userId);
6850
6851            qPos.add(status);
6852
6853            Long count = (Long)q.uniqueResult();
6854
6855            return count.intValue();
6856        }
6857        catch (Exception e) {
6858            throw processException(e);
6859        }
6860        finally {
6861            closeSession(session);
6862        }
6863    }
6864
6865    public int countByG_D_S(long groupId, Date displayDate, int status)
6866        throws SystemException {
6867        Object[] finderArgs = new Object[] {
6868                new Long(groupId),
6869                
6870                displayDate, new Integer(status)
6871            };
6872
6873        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_D_S,
6874                finderArgs, this);
6875
6876        if (count == null) {
6877            Session session = null;
6878
6879            try {
6880                session = openSession();
6881
6882                StringBundler query = new StringBundler(4);
6883
6884                query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
6885
6886                query.append(_FINDER_COLUMN_G_D_S_GROUPID_2);
6887
6888                if (displayDate == null) {
6889                    query.append(_FINDER_COLUMN_G_D_S_DISPLAYDATE_1);
6890                }
6891                else {
6892                    query.append(_FINDER_COLUMN_G_D_S_DISPLAYDATE_2);
6893                }
6894
6895                query.append(_FINDER_COLUMN_G_D_S_STATUS_2);
6896
6897                String sql = query.toString();
6898
6899                Query q = session.createQuery(sql);
6900
6901                QueryPos qPos = QueryPos.getInstance(q);
6902
6903                qPos.add(groupId);
6904
6905                if (displayDate != null) {
6906                    qPos.add(CalendarUtil.getTimestamp(displayDate));
6907                }
6908
6909                qPos.add(status);
6910
6911                count = (Long)q.uniqueResult();
6912            }
6913            catch (Exception e) {
6914                throw processException(e);
6915            }
6916            finally {
6917                if (count == null) {
6918                    count = Long.valueOf(0);
6919                }
6920
6921                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_D_S,
6922                    finderArgs, count);
6923
6924                closeSession(session);
6925            }
6926        }
6927
6928        return count.intValue();
6929    }
6930
6931    public int filterCountByG_D_S(long groupId, Date displayDate, int status)
6932        throws SystemException {
6933        if (!InlineSQLHelperUtil.isEnabled(groupId)) {
6934            return countByG_D_S(groupId, displayDate, status);
6935        }
6936
6937        Session session = null;
6938
6939        try {
6940            session = openSession();
6941
6942            StringBundler query = new StringBundler(4);
6943
6944            query.append(_FILTER_SQL_COUNT_BLOGSENTRY_WHERE);
6945
6946            query.append(_FINDER_COLUMN_G_D_S_GROUPID_2);
6947
6948            if (displayDate == null) {
6949                query.append(_FINDER_COLUMN_G_D_S_DISPLAYDATE_1);
6950            }
6951            else {
6952                query.append(_FINDER_COLUMN_G_D_S_DISPLAYDATE_2);
6953            }
6954
6955            query.append(_FINDER_COLUMN_G_D_S_STATUS_2);
6956
6957            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
6958                    BlogsEntry.class.getName(), _FILTER_COLUMN_ENTRYID,
6959                    _FILTER_COLUMN_USERID, groupId);
6960
6961            SQLQuery q = session.createSQLQuery(sql);
6962
6963            q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
6964
6965            QueryPos qPos = QueryPos.getInstance(q);
6966
6967            qPos.add(groupId);
6968
6969            if (displayDate != null) {
6970                qPos.add(CalendarUtil.getTimestamp(displayDate));
6971            }
6972
6973            qPos.add(status);
6974
6975            Long count = (Long)q.uniqueResult();
6976
6977            return count.intValue();
6978        }
6979        catch (Exception e) {
6980            throw processException(e);
6981        }
6982        finally {
6983            closeSession(session);
6984        }
6985    }
6986
6987    public int countByG_U_D_S(long groupId, long userId, Date displayDate,
6988        int status) throws SystemException {
6989        Object[] finderArgs = new Object[] {
6990                new Long(groupId), new Long(userId),
6991                
6992                displayDate, new Integer(status)
6993            };
6994
6995        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_U_D_S,
6996                finderArgs, this);
6997
6998        if (count == null) {
6999            Session session = null;
7000
7001            try {
7002                session = openSession();
7003
7004                StringBundler query = new StringBundler(5);
7005
7006                query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
7007
7008                query.append(_FINDER_COLUMN_G_U_D_S_GROUPID_2);
7009
7010                query.append(_FINDER_COLUMN_G_U_D_S_USERID_2);
7011
7012                if (displayDate == null) {
7013                    query.append(_FINDER_COLUMN_G_U_D_S_DISPLAYDATE_1);
7014                }
7015                else {
7016                    query.append(_FINDER_COLUMN_G_U_D_S_DISPLAYDATE_2);
7017                }
7018
7019                query.append(_FINDER_COLUMN_G_U_D_S_STATUS_2);
7020
7021                String sql = query.toString();
7022
7023                Query q = session.createQuery(sql);
7024
7025                QueryPos qPos = QueryPos.getInstance(q);
7026
7027                qPos.add(groupId);
7028
7029                qPos.add(userId);
7030
7031                if (displayDate != null) {
7032                    qPos.add(CalendarUtil.getTimestamp(displayDate));
7033                }
7034
7035                qPos.add(status);
7036
7037                count = (Long)q.uniqueResult();
7038            }
7039            catch (Exception e) {
7040                throw processException(e);
7041            }
7042            finally {
7043                if (count == null) {
7044                    count = Long.valueOf(0);
7045                }
7046
7047                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_U_D_S,
7048                    finderArgs, count);
7049
7050                closeSession(session);
7051            }
7052        }
7053
7054        return count.intValue();
7055    }
7056
7057    public int filterCountByG_U_D_S(long groupId, long userId,
7058        Date displayDate, int status) throws SystemException {
7059        if (!InlineSQLHelperUtil.isEnabled(groupId)) {
7060            return countByG_U_D_S(groupId, userId, displayDate, status);
7061        }
7062
7063        Session session = null;
7064
7065        try {
7066            session = openSession();
7067
7068            StringBundler query = new StringBundler(5);
7069
7070            query.append(_FILTER_SQL_COUNT_BLOGSENTRY_WHERE);
7071
7072            query.append(_FINDER_COLUMN_G_U_D_S_GROUPID_2);
7073
7074            query.append(_FINDER_COLUMN_G_U_D_S_USERID_2);
7075
7076            if (displayDate == null) {
7077                query.append(_FINDER_COLUMN_G_U_D_S_DISPLAYDATE_1);
7078            }
7079            else {
7080                query.append(_FINDER_COLUMN_G_U_D_S_DISPLAYDATE_2);
7081            }
7082
7083            query.append(_FINDER_COLUMN_G_U_D_S_STATUS_2);
7084
7085            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
7086                    BlogsEntry.class.getName(), _FILTER_COLUMN_ENTRYID,
7087                    _FILTER_COLUMN_USERID, groupId);
7088
7089            SQLQuery q = session.createSQLQuery(sql);
7090
7091            q.addScalar(COUNT_COLUMN_NAME, Type.LONG);
7092
7093            QueryPos qPos = QueryPos.getInstance(q);
7094
7095            qPos.add(groupId);
7096
7097            qPos.add(userId);
7098
7099            if (displayDate != null) {
7100                qPos.add(CalendarUtil.getTimestamp(displayDate));
7101            }
7102
7103            qPos.add(status);
7104
7105            Long count = (Long)q.uniqueResult();
7106
7107            return count.intValue();
7108        }
7109        catch (Exception e) {
7110            throw processException(e);
7111        }
7112        finally {
7113            closeSession(session);
7114        }
7115    }
7116
7117    public int countAll() throws SystemException {
7118        Object[] finderArgs = new Object[0];
7119
7120        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
7121                finderArgs, this);
7122
7123        if (count == null) {
7124            Session session = null;
7125
7126            try {
7127                session = openSession();
7128
7129                Query q = session.createQuery(_SQL_COUNT_BLOGSENTRY);
7130
7131                count = (Long)q.uniqueResult();
7132            }
7133            catch (Exception e) {
7134                throw processException(e);
7135            }
7136            finally {
7137                if (count == null) {
7138                    count = Long.valueOf(0);
7139                }
7140
7141                FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
7142                    count);
7143
7144                closeSession(session);
7145            }
7146        }
7147
7148        return count.intValue();
7149    }
7150
7151    public void afterPropertiesSet() {
7152        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
7153                    com.liferay.portal.util.PropsUtil.get(
7154                        "value.object.listener.com.liferay.portlet.blogs.model.BlogsEntry")));
7155
7156        if (listenerClassNames.length > 0) {
7157            try {
7158                List<ModelListener<BlogsEntry>> listenersList = new ArrayList<ModelListener<BlogsEntry>>();
7159
7160                for (String listenerClassName : listenerClassNames) {
7161                    listenersList.add((ModelListener<BlogsEntry>)InstanceFactory.newInstance(
7162                            listenerClassName));
7163                }
7164
7165                listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
7166            }
7167            catch (Exception e) {
7168                _log.error(e);
7169            }
7170        }
7171    }
7172
7173    @BeanReference(type = BlogsEntryPersistence.class)
7174    protected BlogsEntryPersistence blogsEntryPersistence;
7175    @BeanReference(type = BlogsStatsUserPersistence.class)
7176    protected BlogsStatsUserPersistence blogsStatsUserPersistence;
7177    @BeanReference(type = CompanyPersistence.class)
7178    protected CompanyPersistence companyPersistence;
7179    @BeanReference(type = GroupPersistence.class)
7180    protected GroupPersistence groupPersistence;
7181    @BeanReference(type = OrganizationPersistence.class)
7182    protected OrganizationPersistence organizationPersistence;
7183    @BeanReference(type = PortletPreferencesPersistence.class)
7184    protected PortletPreferencesPersistence portletPreferencesPersistence;
7185    @BeanReference(type = ResourcePersistence.class)
7186    protected ResourcePersistence resourcePersistence;
7187    @BeanReference(type = UserPersistence.class)
7188    protected UserPersistence userPersistence;
7189    @BeanReference(type = WorkflowInstanceLinkPersistence.class)
7190    protected WorkflowInstanceLinkPersistence workflowInstanceLinkPersistence;
7191    @BeanReference(type = AssetEntryPersistence.class)
7192    protected AssetEntryPersistence assetEntryPersistence;
7193    @BeanReference(type = AssetTagPersistence.class)
7194    protected AssetTagPersistence assetTagPersistence;
7195    @BeanReference(type = ExpandoValuePersistence.class)
7196    protected ExpandoValuePersistence expandoValuePersistence;
7197    @BeanReference(type = MBMessagePersistence.class)
7198    protected MBMessagePersistence mbMessagePersistence;
7199    @BeanReference(type = RatingsStatsPersistence.class)
7200    protected RatingsStatsPersistence ratingsStatsPersistence;
7201    @BeanReference(type = SocialActivityPersistence.class)
7202    protected SocialActivityPersistence socialActivityPersistence;
7203    private static final String _SQL_SELECT_BLOGSENTRY = "SELECT blogsEntry FROM BlogsEntry blogsEntry";
7204    private static final String _SQL_SELECT_BLOGSENTRY_WHERE = "SELECT blogsEntry FROM BlogsEntry blogsEntry WHERE ";
7205    private static final String _SQL_COUNT_BLOGSENTRY = "SELECT COUNT(blogsEntry) FROM BlogsEntry blogsEntry";
7206    private static final String _SQL_COUNT_BLOGSENTRY_WHERE = "SELECT COUNT(blogsEntry) FROM BlogsEntry blogsEntry WHERE ";
7207    private static final String _FINDER_COLUMN_UUID_UUID_1 = "blogsEntry.uuid IS NULL";
7208    private static final String _FINDER_COLUMN_UUID_UUID_2 = "blogsEntry.uuid = ?";
7209    private static final String _FINDER_COLUMN_UUID_UUID_3 = "(blogsEntry.uuid IS NULL OR blogsEntry.uuid = ?)";
7210    private static final String _FINDER_COLUMN_UUID_G_UUID_1 = "blogsEntry.uuid IS NULL AND ";
7211    private static final String _FINDER_COLUMN_UUID_G_UUID_2 = "blogsEntry.uuid = ? AND ";
7212    private static final String _FINDER_COLUMN_UUID_G_UUID_3 = "(blogsEntry.uuid IS NULL OR blogsEntry.uuid = ?) AND ";
7213    private static final String _FINDER_COLUMN_UUID_G_GROUPID_2 = "blogsEntry.groupId = ?";
7214    private static final String _FINDER_COLUMN_GROUPID_GROUPID_2 = "blogsEntry.groupId = ?";
7215    private static final String _FINDER_COLUMN_COMPANYID_COMPANYID_2 = "blogsEntry.companyId = ?";
7216    private static final String _FINDER_COLUMN_C_U_COMPANYID_2 = "blogsEntry.companyId = ? AND ";
7217    private static final String _FINDER_COLUMN_C_U_USERID_2 = "blogsEntry.userId = ?";
7218    private static final String _FINDER_COLUMN_C_D_COMPANYID_2 = "blogsEntry.companyId = ? AND ";
7219    private static final String _FINDER_COLUMN_C_D_DISPLAYDATE_1 = "blogsEntry.displayDate < NULL";
7220    private static final String _FINDER_COLUMN_C_D_DISPLAYDATE_2 = "blogsEntry.displayDate < ?";
7221    private static final String _FINDER_COLUMN_C_S_COMPANYID_2 = "blogsEntry.companyId = ? AND ";
7222    private static final String _FINDER_COLUMN_C_S_STATUS_2 = "blogsEntry.status = ?";
7223    private static final String _FINDER_COLUMN_G_UT_GROUPID_2 = "blogsEntry.groupId = ? AND ";
7224    private static final String _FINDER_COLUMN_G_UT_URLTITLE_1 = "blogsEntry.urlTitle IS NULL";
7225    private static final String _FINDER_COLUMN_G_UT_URLTITLE_2 = "blogsEntry.urlTitle = ?";
7226    private static final String _FINDER_COLUMN_G_UT_URLTITLE_3 = "(blogsEntry.urlTitle IS NULL OR blogsEntry.urlTitle = ?)";
7227    private static final String _FINDER_COLUMN_G_D_GROUPID_2 = "blogsEntry.groupId = ? AND ";
7228    private static final String _FINDER_COLUMN_G_D_DISPLAYDATE_1 = "blogsEntry.displayDate < NULL";
7229    private static final String _FINDER_COLUMN_G_D_DISPLAYDATE_2 = "blogsEntry.displayDate < ?";
7230    private static final String _FINDER_COLUMN_G_S_GROUPID_2 = "blogsEntry.groupId = ? AND ";
7231    private static final String _FINDER_COLUMN_G_S_STATUS_2 = "blogsEntry.status = ?";
7232    private static final String _FINDER_COLUMN_C_U_S_COMPANYID_2 = "blogsEntry.companyId = ? AND ";
7233    private static final String _FINDER_COLUMN_C_U_S_USERID_2 = "blogsEntry.userId = ? AND ";
7234    private static final String _FINDER_COLUMN_C_U_S_STATUS_2 = "blogsEntry.status = ?";
7235    private static final String _FINDER_COLUMN_C_D_S_COMPANYID_2 = "blogsEntry.companyId = ? AND ";
7236    private static final String _FINDER_COLUMN_C_D_S_DISPLAYDATE_1 = "blogsEntry.displayDate < NULL AND ";
7237    private static final String _FINDER_COLUMN_C_D_S_DISPLAYDATE_2 = "blogsEntry.displayDate < ? AND ";
7238    private static final String _FINDER_COLUMN_C_D_S_STATUS_2 = "blogsEntry.status = ?";
7239    private static final String _FINDER_COLUMN_G_U_D_GROUPID_2 = "blogsEntry.groupId = ? AND ";
7240    private static final String _FINDER_COLUMN_G_U_D_USERID_2 = "blogsEntry.userId = ? AND ";
7241    private static final String _FINDER_COLUMN_G_U_D_DISPLAYDATE_1 = "blogsEntry.displayDate < NULL";
7242    private static final String _FINDER_COLUMN_G_U_D_DISPLAYDATE_2 = "blogsEntry.displayDate < ?";
7243    private static final String _FINDER_COLUMN_G_U_S_GROUPID_2 = "blogsEntry.groupId = ? AND ";
7244    private static final String _FINDER_COLUMN_G_U_S_USERID_2 = "blogsEntry.userId = ? AND ";
7245    private static final String _FINDER_COLUMN_G_U_S_STATUS_2 = "blogsEntry.status = ?";
7246    private static final String _FINDER_COLUMN_G_D_S_GROUPID_2 = "blogsEntry.groupId = ? AND ";
7247    private static final String _FINDER_COLUMN_G_D_S_DISPLAYDATE_1 = "blogsEntry.displayDate < NULL AND ";
7248    private static final String _FINDER_COLUMN_G_D_S_DISPLAYDATE_2 = "blogsEntry.displayDate < ? AND ";
7249    private static final String _FINDER_COLUMN_G_D_S_STATUS_2 = "blogsEntry.status = ?";
7250    private static final String _FINDER_COLUMN_G_U_D_S_GROUPID_2 = "blogsEntry.groupId = ? AND ";
7251    private static final String _FINDER_COLUMN_G_U_D_S_USERID_2 = "blogsEntry.userId = ? AND ";
7252    private static final String _FINDER_COLUMN_G_U_D_S_DISPLAYDATE_1 = "blogsEntry.displayDate < NULL AND ";
7253    private static final String _FINDER_COLUMN_G_U_D_S_DISPLAYDATE_2 = "blogsEntry.displayDate < ? AND ";
7254    private static final String _FINDER_COLUMN_G_U_D_S_STATUS_2 = "blogsEntry.status = ?";
7255    private static final String _FILTER_SQL_SELECT_BLOGSENTRY_WHERE = "SELECT DISTINCT {blogsEntry.*} FROM BlogsEntry blogsEntry WHERE ";
7256    private static final String _FILTER_SQL_COUNT_BLOGSENTRY_WHERE = "SELECT COUNT(DISTINCT blogsEntry.entryId) AS COUNT_VALUE FROM BlogsEntry blogsEntry WHERE ";
7257    private static final String _FILTER_COLUMN_ENTRYID = "blogsEntry.entryId";
7258    private static final String _FILTER_COLUMN_USERID = "blogsEntry.userId";
7259    private static final String _FILTER_ENTITY_ALIAS = "blogsEntry";
7260    private static final String _ORDER_BY_ENTITY_ALIAS = "blogsEntry.";
7261    private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No BlogsEntry exists with the primary key ";
7262    private static final String _NO_SUCH_ENTITY_WITH_KEY = "No BlogsEntry exists with the key {";
7263    private static Log _log = LogFactoryUtil.getLog(BlogsEntryPersistenceImpl.class);
7264}