1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * The contents of this file are subject to the terms of the Liferay Enterprise
5    * Subscription License ("License"). You may not use this file except in
6    * compliance with the License. You can obtain a copy of the License by
7    * contacting Liferay, Inc. See the License for the specific language governing
8    * permissions and limitations under the License, including but not limited to
9    * distribution rights of the Software.
10   *
11   *
12   *
13   */
14  
15  package com.liferay.portlet.blogs.service.persistence;
16  
17  import com.liferay.portal.NoSuchModelException;
18  import com.liferay.portal.SystemException;
19  import com.liferay.portal.kernel.annotation.BeanReference;
20  import com.liferay.portal.kernel.cache.CacheRegistry;
21  import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
22  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
23  import com.liferay.portal.kernel.dao.orm.FinderPath;
24  import com.liferay.portal.kernel.dao.orm.Query;
25  import com.liferay.portal.kernel.dao.orm.QueryPos;
26  import com.liferay.portal.kernel.dao.orm.QueryUtil;
27  import com.liferay.portal.kernel.dao.orm.Session;
28  import com.liferay.portal.kernel.log.Log;
29  import com.liferay.portal.kernel.log.LogFactoryUtil;
30  import com.liferay.portal.kernel.sanitizer.Sanitizer;
31  import com.liferay.portal.kernel.sanitizer.SanitizerException;
32  import com.liferay.portal.kernel.sanitizer.SanitizerUtil;
33  import com.liferay.portal.kernel.util.CalendarUtil;
34  import com.liferay.portal.kernel.util.ContentTypes;
35  import com.liferay.portal.kernel.util.GetterUtil;
36  import com.liferay.portal.kernel.util.InstanceFactory;
37  import com.liferay.portal.kernel.util.OrderByComparator;
38  import com.liferay.portal.kernel.util.StringBundler;
39  import com.liferay.portal.kernel.util.StringPool;
40  import com.liferay.portal.kernel.util.StringUtil;
41  import com.liferay.portal.kernel.util.Validator;
42  import com.liferay.portal.kernel.uuid.PortalUUIDUtil;
43  import com.liferay.portal.model.ModelListener;
44  import com.liferay.portal.security.auth.PrincipalThreadLocal;
45  import com.liferay.portal.service.persistence.BatchSessionUtil;
46  import com.liferay.portal.service.persistence.CompanyPersistence;
47  import com.liferay.portal.service.persistence.GroupPersistence;
48  import com.liferay.portal.service.persistence.OrganizationPersistence;
49  import com.liferay.portal.service.persistence.PortletPreferencesPersistence;
50  import com.liferay.portal.service.persistence.ResourcePersistence;
51  import com.liferay.portal.service.persistence.UserPersistence;
52  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
53  
54  import com.liferay.portlet.blogs.NoSuchEntryException;
55  import com.liferay.portlet.blogs.model.BlogsEntry;
56  import com.liferay.portlet.blogs.model.impl.BlogsEntryImpl;
57  import com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl;
58  import com.liferay.portlet.expando.service.persistence.ExpandoValuePersistence;
59  import com.liferay.portlet.messageboards.service.persistence.MBMessagePersistence;
60  import com.liferay.portlet.ratings.service.persistence.RatingsStatsPersistence;
61  import com.liferay.portlet.social.service.persistence.SocialActivityPersistence;
62  import com.liferay.portlet.tags.service.persistence.TagsAssetPersistence;
63  import com.liferay.portlet.tags.service.persistence.TagsEntryPersistence;
64  
65  import java.io.Serializable;
66  
67  import java.util.ArrayList;
68  import java.util.Collections;
69  import java.util.Date;
70  import java.util.List;
71  
72  /**
73   * <a href="BlogsEntryPersistenceImpl.java.html"><b><i>View Source</i></b></a>
74   *
75   * <p>
76   * ServiceBuilder generated this class. Modifications in this class will be
77   * overwritten the next time is generated.
78   * </p>
79   *
80   * @author    Brian Wing Shun Chan
81   * @see       BlogsEntryPersistence
82   * @see       BlogsEntryUtil
83   * @generated
84   */
85  public class BlogsEntryPersistenceImpl extends BasePersistenceImpl<BlogsEntry>
86      implements BlogsEntryPersistence {
87      public static final String FINDER_CLASS_NAME_ENTITY = BlogsEntryImpl.class.getName();
88      public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
89          ".List";
90      public static final FinderPath FINDER_PATH_FIND_BY_UUID = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
91              BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
92              "findByUuid",
93              new String[] {
94                  String.class.getName(),
95                  
96              "java.lang.Integer", "java.lang.Integer",
97                  "com.liferay.portal.kernel.util.OrderByComparator"
98              });
99      public static final FinderPath FINDER_PATH_COUNT_BY_UUID = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
100             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
101             "countByUuid", new String[] { String.class.getName() });
102     public static final FinderPath FINDER_PATH_FETCH_BY_UUID_G = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
103             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_ENTITY,
104             "fetchByUUID_G",
105             new String[] { String.class.getName(), Long.class.getName() });
106     public static final FinderPath FINDER_PATH_COUNT_BY_UUID_G = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
107             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
108             "countByUUID_G",
109             new String[] { String.class.getName(), Long.class.getName() });
110     public static final FinderPath FINDER_PATH_FIND_BY_GROUPID = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
111             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
112             "findByGroupId",
113             new String[] {
114                 Long.class.getName(),
115                 
116             "java.lang.Integer", "java.lang.Integer",
117                 "com.liferay.portal.kernel.util.OrderByComparator"
118             });
119     public static final FinderPath FINDER_PATH_COUNT_BY_GROUPID = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
120             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
121             "countByGroupId", new String[] { Long.class.getName() });
122     public static final FinderPath FINDER_PATH_FIND_BY_COMPANYID = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
123             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
124             "findByCompanyId",
125             new String[] {
126                 Long.class.getName(),
127                 
128             "java.lang.Integer", "java.lang.Integer",
129                 "com.liferay.portal.kernel.util.OrderByComparator"
130             });
131     public static final FinderPath FINDER_PATH_COUNT_BY_COMPANYID = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
132             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
133             "countByCompanyId", new String[] { Long.class.getName() });
134     public static final FinderPath FINDER_PATH_FIND_BY_G_U = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
135             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
136             "findByG_U",
137             new String[] {
138                 Long.class.getName(), Long.class.getName(),
139                 
140             "java.lang.Integer", "java.lang.Integer",
141                 "com.liferay.portal.kernel.util.OrderByComparator"
142             });
143     public static final FinderPath FINDER_PATH_COUNT_BY_G_U = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
144             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
145             "countByG_U",
146             new String[] { Long.class.getName(), Long.class.getName() });
147     public static final FinderPath FINDER_PATH_FETCH_BY_G_UT = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
148             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_ENTITY,
149             "fetchByG_UT",
150             new String[] { Long.class.getName(), String.class.getName() });
151     public static final FinderPath FINDER_PATH_COUNT_BY_G_UT = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
152             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
153             "countByG_UT",
154             new String[] { Long.class.getName(), String.class.getName() });
155     public static final FinderPath FINDER_PATH_FIND_BY_G_D_D = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
156             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
157             "findByG_D_D",
158             new String[] {
159                 Long.class.getName(), Date.class.getName(),
160                 Boolean.class.getName(),
161                 
162             "java.lang.Integer", "java.lang.Integer",
163                 "com.liferay.portal.kernel.util.OrderByComparator"
164             });
165     public static final FinderPath FINDER_PATH_COUNT_BY_G_D_D = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
166             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
167             "countByG_D_D",
168             new String[] {
169                 Long.class.getName(), Date.class.getName(),
170                 Boolean.class.getName()
171             });
172     public static final FinderPath FINDER_PATH_FIND_BY_C_D_D = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
173             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
174             "findByC_D_D",
175             new String[] {
176                 Long.class.getName(), Date.class.getName(),
177                 Boolean.class.getName(),
178                 
179             "java.lang.Integer", "java.lang.Integer",
180                 "com.liferay.portal.kernel.util.OrderByComparator"
181             });
182     public static final FinderPath FINDER_PATH_COUNT_BY_C_D_D = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
183             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
184             "countByC_D_D",
185             new String[] {
186                 Long.class.getName(), Date.class.getName(),
187                 Boolean.class.getName()
188             });
189     public static final FinderPath FINDER_PATH_FIND_BY_G_U_D_D = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
190             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
191             "findByG_U_D_D",
192             new String[] {
193                 Long.class.getName(), Long.class.getName(), Date.class.getName(),
194                 Boolean.class.getName(),
195                 
196             "java.lang.Integer", "java.lang.Integer",
197                 "com.liferay.portal.kernel.util.OrderByComparator"
198             });
199     public static final FinderPath FINDER_PATH_COUNT_BY_G_U_D_D = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
200             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
201             "countByG_U_D_D",
202             new String[] {
203                 Long.class.getName(), Long.class.getName(), Date.class.getName(),
204                 Boolean.class.getName()
205             });
206     public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
207             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
208             "findAll", new String[0]);
209     public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
210             BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
211             "countAll", new String[0]);
212 
213     public void cacheResult(BlogsEntry blogsEntry) {
214         EntityCacheUtil.putResult(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
215             BlogsEntryImpl.class, blogsEntry.getPrimaryKey(), blogsEntry);
216 
217         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
218             new Object[] { blogsEntry.getUuid(), new Long(
219                     blogsEntry.getGroupId()) }, blogsEntry);
220 
221         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_UT,
222             new Object[] {
223                 new Long(blogsEntry.getGroupId()),
224                 
225             blogsEntry.getUrlTitle()
226             }, blogsEntry);
227     }
228 
229     public void cacheResult(List<BlogsEntry> blogsEntries) {
230         for (BlogsEntry blogsEntry : blogsEntries) {
231             if (EntityCacheUtil.getResult(
232                         BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
233                         BlogsEntryImpl.class, blogsEntry.getPrimaryKey(), this) == null) {
234                 cacheResult(blogsEntry);
235             }
236         }
237     }
238 
239     public void clearCache() {
240         CacheRegistry.clear(BlogsEntryImpl.class.getName());
241         EntityCacheUtil.clearCache(BlogsEntryImpl.class.getName());
242         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
243         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
244     }
245 
246     public void clearCache(BlogsEntry blogsEntry) {
247         EntityCacheUtil.removeResult(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
248             BlogsEntryImpl.class, blogsEntry.getPrimaryKey());
249 
250         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
251             new Object[] { blogsEntry.getUuid(), new Long(
252                     blogsEntry.getGroupId()) });
253 
254         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_UT,
255             new Object[] {
256                 new Long(blogsEntry.getGroupId()),
257                 
258             blogsEntry.getUrlTitle()
259             });
260     }
261 
262     public BlogsEntry create(long entryId) {
263         BlogsEntry blogsEntry = new BlogsEntryImpl();
264 
265         blogsEntry.setNew(true);
266         blogsEntry.setPrimaryKey(entryId);
267 
268         String uuid = PortalUUIDUtil.generate();
269 
270         blogsEntry.setUuid(uuid);
271 
272         return blogsEntry;
273     }
274 
275     public BlogsEntry remove(Serializable primaryKey)
276         throws NoSuchModelException, SystemException {
277         return remove(((Long)primaryKey).longValue());
278     }
279 
280     public BlogsEntry remove(long entryId)
281         throws NoSuchEntryException, SystemException {
282         Session session = null;
283 
284         try {
285             session = openSession();
286 
287             BlogsEntry blogsEntry = (BlogsEntry)session.get(BlogsEntryImpl.class,
288                     new Long(entryId));
289 
290             if (blogsEntry == null) {
291                 if (_log.isWarnEnabled()) {
292                     _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + entryId);
293                 }
294 
295                 throw new NoSuchEntryException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
296                     entryId);
297             }
298 
299             return remove(blogsEntry);
300         }
301         catch (NoSuchEntryException nsee) {
302             throw nsee;
303         }
304         catch (Exception e) {
305             throw processException(e);
306         }
307         finally {
308             closeSession(session);
309         }
310     }
311 
312     protected BlogsEntry removeImpl(BlogsEntry blogsEntry)
313         throws SystemException {
314         blogsEntry = toUnwrappedModel(blogsEntry);
315 
316         Session session = null;
317 
318         try {
319             session = openSession();
320 
321             BatchSessionUtil.delete(session, blogsEntry);
322         }
323         catch (Exception e) {
324             throw processException(e);
325         }
326         finally {
327             closeSession(session);
328         }
329 
330         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
331 
332         BlogsEntryModelImpl blogsEntryModelImpl = (BlogsEntryModelImpl)blogsEntry;
333 
334         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
335             new Object[] {
336                 blogsEntryModelImpl.getOriginalUuid(),
337                 new Long(blogsEntryModelImpl.getOriginalGroupId())
338             });
339 
340         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_UT,
341             new Object[] {
342                 new Long(blogsEntryModelImpl.getOriginalGroupId()),
343                 
344             blogsEntryModelImpl.getOriginalUrlTitle()
345             });
346 
347         EntityCacheUtil.removeResult(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
348             BlogsEntryImpl.class, blogsEntry.getPrimaryKey());
349 
350         return blogsEntry;
351     }
352 
353     /**
354      * @deprecated Use {@link BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)}.
355      */
356     public BlogsEntry update(BlogsEntry blogsEntry) throws SystemException {
357         if (_log.isWarnEnabled()) {
358             _log.warn(
359                 "Using the deprecated update(BlogsEntry blogsEntry) method. Use update(BlogsEntry blogsEntry, boolean merge) instead.");
360         }
361 
362         return update(blogsEntry, false);
363     }
364 
365     public BlogsEntry updateImpl(
366         com.liferay.portlet.blogs.model.BlogsEntry blogsEntry, boolean merge)
367         throws SystemException {
368         blogsEntry = toUnwrappedModel(blogsEntry);
369 
370         boolean isNew = blogsEntry.isNew();
371 
372         BlogsEntryModelImpl blogsEntryModelImpl = (BlogsEntryModelImpl)blogsEntry;
373 
374         if (Validator.isNull(blogsEntry.getUuid())) {
375             String uuid = PortalUUIDUtil.generate();
376 
377             blogsEntry.setUuid(uuid);
378         }
379 
380         long userId = GetterUtil.getLong(PrincipalThreadLocal.getName());
381 
382         if (userId > 0) {
383             long companyId = blogsEntry.getCompanyId();
384 
385             long groupId = blogsEntry.getGroupId();
386 
387             long entryId = 0;
388 
389             if (!isNew) {
390                 entryId = blogsEntry.getPrimaryKey();
391             }
392 
393             try {
394                 blogsEntry.setTitle(SanitizerUtil.sanitize(companyId, groupId,
395                         userId,
396                         com.liferay.portlet.blogs.model.BlogsEntry.class.getName(),
397                         entryId, ContentTypes.TEXT_PLAIN, Sanitizer.MODE_ALL,
398                         blogsEntry.getTitle(), null));
399 
400                 blogsEntry.setContent(SanitizerUtil.sanitize(companyId,
401                         groupId, userId,
402                         com.liferay.portlet.blogs.model.BlogsEntry.class.getName(),
403                         entryId, ContentTypes.TEXT_HTML, Sanitizer.MODE_ALL,
404                         blogsEntry.getContent(), null));
405             }
406             catch (SanitizerException se) {
407                 throw new SystemException(se);
408             }
409         }
410 
411         Session session = null;
412 
413         try {
414             session = openSession();
415 
416             BatchSessionUtil.update(session, blogsEntry, merge);
417 
418             blogsEntry.setNew(false);
419         }
420         catch (Exception e) {
421             throw processException(e);
422         }
423         finally {
424             closeSession(session);
425         }
426 
427         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
428 
429         EntityCacheUtil.putResult(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
430             BlogsEntryImpl.class, blogsEntry.getPrimaryKey(), blogsEntry);
431 
432         if (!isNew &&
433                 (!Validator.equals(blogsEntry.getUuid(),
434                     blogsEntryModelImpl.getOriginalUuid()) ||
435                 (blogsEntry.getGroupId() != blogsEntryModelImpl.getOriginalGroupId()))) {
436             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
437                 new Object[] {
438                     blogsEntryModelImpl.getOriginalUuid(),
439                     new Long(blogsEntryModelImpl.getOriginalGroupId())
440                 });
441         }
442 
443         if (isNew ||
444                 (!Validator.equals(blogsEntry.getUuid(),
445                     blogsEntryModelImpl.getOriginalUuid()) ||
446                 (blogsEntry.getGroupId() != blogsEntryModelImpl.getOriginalGroupId()))) {
447             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
448                 new Object[] {
449                     blogsEntry.getUuid(), new Long(blogsEntry.getGroupId())
450                 }, blogsEntry);
451         }
452 
453         if (!isNew &&
454                 ((blogsEntry.getGroupId() != blogsEntryModelImpl.getOriginalGroupId()) ||
455                 !Validator.equals(blogsEntry.getUrlTitle(),
456                     blogsEntryModelImpl.getOriginalUrlTitle()))) {
457             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_UT,
458                 new Object[] {
459                     new Long(blogsEntryModelImpl.getOriginalGroupId()),
460                     
461                 blogsEntryModelImpl.getOriginalUrlTitle()
462                 });
463         }
464 
465         if (isNew ||
466                 ((blogsEntry.getGroupId() != blogsEntryModelImpl.getOriginalGroupId()) ||
467                 !Validator.equals(blogsEntry.getUrlTitle(),
468                     blogsEntryModelImpl.getOriginalUrlTitle()))) {
469             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_UT,
470                 new Object[] {
471                     new Long(blogsEntry.getGroupId()),
472                     
473                 blogsEntry.getUrlTitle()
474                 }, blogsEntry);
475         }
476 
477         return blogsEntry;
478     }
479 
480     protected BlogsEntry toUnwrappedModel(BlogsEntry blogsEntry) {
481         if (blogsEntry instanceof BlogsEntryImpl) {
482             return blogsEntry;
483         }
484 
485         BlogsEntryImpl blogsEntryImpl = new BlogsEntryImpl();
486 
487         blogsEntryImpl.setNew(blogsEntry.isNew());
488         blogsEntryImpl.setPrimaryKey(blogsEntry.getPrimaryKey());
489 
490         blogsEntryImpl.setUuid(blogsEntry.getUuid());
491         blogsEntryImpl.setEntryId(blogsEntry.getEntryId());
492         blogsEntryImpl.setGroupId(blogsEntry.getGroupId());
493         blogsEntryImpl.setCompanyId(blogsEntry.getCompanyId());
494         blogsEntryImpl.setUserId(blogsEntry.getUserId());
495         blogsEntryImpl.setUserName(blogsEntry.getUserName());
496         blogsEntryImpl.setCreateDate(blogsEntry.getCreateDate());
497         blogsEntryImpl.setModifiedDate(blogsEntry.getModifiedDate());
498         blogsEntryImpl.setTitle(blogsEntry.getTitle());
499         blogsEntryImpl.setUrlTitle(blogsEntry.getUrlTitle());
500         blogsEntryImpl.setContent(blogsEntry.getContent());
501         blogsEntryImpl.setDisplayDate(blogsEntry.getDisplayDate());
502         blogsEntryImpl.setDraft(blogsEntry.isDraft());
503         blogsEntryImpl.setAllowTrackbacks(blogsEntry.isAllowTrackbacks());
504         blogsEntryImpl.setTrackbacks(blogsEntry.getTrackbacks());
505 
506         return blogsEntryImpl;
507     }
508 
509     public BlogsEntry findByPrimaryKey(Serializable primaryKey)
510         throws NoSuchModelException, SystemException {
511         return findByPrimaryKey(((Long)primaryKey).longValue());
512     }
513 
514     public BlogsEntry findByPrimaryKey(long entryId)
515         throws NoSuchEntryException, SystemException {
516         BlogsEntry blogsEntry = fetchByPrimaryKey(entryId);
517 
518         if (blogsEntry == null) {
519             if (_log.isWarnEnabled()) {
520                 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + entryId);
521             }
522 
523             throw new NoSuchEntryException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
524                 entryId);
525         }
526 
527         return blogsEntry;
528     }
529 
530     public BlogsEntry fetchByPrimaryKey(Serializable primaryKey)
531         throws SystemException {
532         return fetchByPrimaryKey(((Long)primaryKey).longValue());
533     }
534 
535     public BlogsEntry fetchByPrimaryKey(long entryId) throws SystemException {
536         BlogsEntry blogsEntry = (BlogsEntry)EntityCacheUtil.getResult(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
537                 BlogsEntryImpl.class, entryId, this);
538 
539         if (blogsEntry == null) {
540             Session session = null;
541 
542             try {
543                 session = openSession();
544 
545                 blogsEntry = (BlogsEntry)session.get(BlogsEntryImpl.class,
546                         new Long(entryId));
547             }
548             catch (Exception e) {
549                 throw processException(e);
550             }
551             finally {
552                 if (blogsEntry != null) {
553                     cacheResult(blogsEntry);
554                 }
555 
556                 closeSession(session);
557             }
558         }
559 
560         return blogsEntry;
561     }
562 
563     public List<BlogsEntry> findByUuid(String uuid) throws SystemException {
564         return findByUuid(uuid, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
565     }
566 
567     public List<BlogsEntry> findByUuid(String uuid, int start, int end)
568         throws SystemException {
569         return findByUuid(uuid, start, end, null);
570     }
571 
572     public List<BlogsEntry> findByUuid(String uuid, int start, int end,
573         OrderByComparator orderByComparator) throws SystemException {
574         Object[] finderArgs = new Object[] {
575                 uuid,
576                 
577                 String.valueOf(start), String.valueOf(end),
578                 String.valueOf(orderByComparator)
579             };
580 
581         List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_UUID,
582                 finderArgs, this);
583 
584         if (list == null) {
585             StringBundler query = null;
586 
587             if (orderByComparator != null) {
588                 query = new StringBundler(3 +
589                         (orderByComparator.getOrderByFields().length * 3));
590             }
591             else {
592                 query = new StringBundler(3);
593             }
594 
595             query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
596 
597             if (uuid == null) {
598                 query.append(_FINDER_COLUMN_UUID_UUID_1);
599             }
600             else {
601                 if (uuid.equals(StringPool.BLANK)) {
602                     query.append(_FINDER_COLUMN_UUID_UUID_3);
603                 }
604                 else {
605                     query.append(_FINDER_COLUMN_UUID_UUID_2);
606                 }
607             }
608 
609             if (orderByComparator != null) {
610                 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
611                     orderByComparator);
612             }
613 
614             else {
615                 query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
616             }
617 
618             String sql = query.toString();
619 
620             Session session = null;
621 
622             try {
623                 session = openSession();
624 
625                 Query q = session.createQuery(sql);
626 
627                 QueryPos qPos = QueryPos.getInstance(q);
628 
629                 if (uuid != null) {
630                     qPos.add(uuid);
631                 }
632 
633                 list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start,
634                         end);
635             }
636             catch (Exception e) {
637                 throw processException(e);
638             }
639             finally {
640                 if (list == null) {
641                     list = new ArrayList<BlogsEntry>();
642                 }
643 
644                 cacheResult(list);
645 
646                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_UUID, finderArgs,
647                     list);
648 
649                 closeSession(session);
650             }
651         }
652 
653         return list;
654     }
655 
656     public BlogsEntry findByUuid_First(String uuid,
657         OrderByComparator orderByComparator)
658         throws NoSuchEntryException, SystemException {
659         List<BlogsEntry> list = findByUuid(uuid, 0, 1, orderByComparator);
660 
661         if (list.isEmpty()) {
662             StringBundler msg = new StringBundler(4);
663 
664             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
665 
666             msg.append("uuid=");
667             msg.append(uuid);
668 
669             msg.append(StringPool.CLOSE_CURLY_BRACE);
670 
671             throw new NoSuchEntryException(msg.toString());
672         }
673         else {
674             return list.get(0);
675         }
676     }
677 
678     public BlogsEntry findByUuid_Last(String uuid,
679         OrderByComparator orderByComparator)
680         throws NoSuchEntryException, SystemException {
681         int count = countByUuid(uuid);
682 
683         List<BlogsEntry> list = findByUuid(uuid, count - 1, count,
684                 orderByComparator);
685 
686         if (list.isEmpty()) {
687             StringBundler msg = new StringBundler(4);
688 
689             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
690 
691             msg.append("uuid=");
692             msg.append(uuid);
693 
694             msg.append(StringPool.CLOSE_CURLY_BRACE);
695 
696             throw new NoSuchEntryException(msg.toString());
697         }
698         else {
699             return list.get(0);
700         }
701     }
702 
703     public BlogsEntry[] findByUuid_PrevAndNext(long entryId, String uuid,
704         OrderByComparator orderByComparator)
705         throws NoSuchEntryException, SystemException {
706         BlogsEntry blogsEntry = findByPrimaryKey(entryId);
707 
708         Session session = null;
709 
710         try {
711             session = openSession();
712 
713             BlogsEntry[] array = new BlogsEntryImpl[3];
714 
715             array[0] = getByUuid_PrevAndNext(session, blogsEntry, uuid,
716                     orderByComparator, true);
717 
718             array[1] = blogsEntry;
719 
720             array[2] = getByUuid_PrevAndNext(session, blogsEntry, uuid,
721                     orderByComparator, false);
722 
723             return array;
724         }
725         catch (Exception e) {
726             throw processException(e);
727         }
728         finally {
729             closeSession(session);
730         }
731     }
732 
733     protected BlogsEntry getByUuid_PrevAndNext(Session session,
734         BlogsEntry blogsEntry, String uuid,
735         OrderByComparator orderByComparator, boolean previous) {
736         StringBundler query = null;
737 
738         if (orderByComparator != null) {
739             query = new StringBundler(6 +
740                     (orderByComparator.getOrderByFields().length * 6));
741         }
742         else {
743             query = new StringBundler(3);
744         }
745 
746         query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
747 
748         if (uuid == null) {
749             query.append(_FINDER_COLUMN_UUID_UUID_1);
750         }
751         else {
752             if (uuid.equals(StringPool.BLANK)) {
753                 query.append(_FINDER_COLUMN_UUID_UUID_3);
754             }
755             else {
756                 query.append(_FINDER_COLUMN_UUID_UUID_2);
757             }
758         }
759 
760         if (orderByComparator != null) {
761             String[] orderByFields = orderByComparator.getOrderByFields();
762 
763             if (orderByFields.length > 0) {
764                 query.append(WHERE_AND);
765             }
766 
767             for (int i = 0; i < orderByFields.length; i++) {
768                 query.append(_ORDER_BY_ENTITY_ALIAS);
769                 query.append(orderByFields[i]);
770 
771                 if ((i + 1) < orderByFields.length) {
772                     if (orderByComparator.isAscending() ^ previous) {
773                         query.append(WHERE_GREATER_THAN_HAS_NEXT);
774                     }
775                     else {
776                         query.append(WHERE_LESSER_THAN_HAS_NEXT);
777                     }
778                 }
779                 else {
780                     if (orderByComparator.isAscending() ^ previous) {
781                         query.append(WHERE_GREATER_THAN);
782                     }
783                     else {
784                         query.append(WHERE_LESSER_THAN);
785                     }
786                 }
787             }
788 
789             query.append(ORDER_BY_CLAUSE);
790 
791             for (int i = 0; i < orderByFields.length; i++) {
792                 query.append(_ORDER_BY_ENTITY_ALIAS);
793                 query.append(orderByFields[i]);
794 
795                 if ((i + 1) < orderByFields.length) {
796                     if (orderByComparator.isAscending() ^ previous) {
797                         query.append(ORDER_BY_ASC_HAS_NEXT);
798                     }
799                     else {
800                         query.append(ORDER_BY_DESC_HAS_NEXT);
801                     }
802                 }
803                 else {
804                     if (orderByComparator.isAscending() ^ previous) {
805                         query.append(ORDER_BY_ASC);
806                     }
807                     else {
808                         query.append(ORDER_BY_DESC);
809                     }
810                 }
811             }
812         }
813 
814         else {
815             query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
816         }
817 
818         String sql = query.toString();
819 
820         Query q = session.createQuery(sql);
821 
822         q.setFirstResult(0);
823         q.setMaxResults(2);
824 
825         QueryPos qPos = QueryPos.getInstance(q);
826 
827         if (uuid != null) {
828             qPos.add(uuid);
829         }
830 
831         if (orderByComparator != null) {
832             Object[] values = orderByComparator.getOrderByValues(blogsEntry);
833 
834             for (Object value : values) {
835                 qPos.add(value);
836             }
837         }
838 
839         List<BlogsEntry> list = q.list();
840 
841         if (list.size() == 2) {
842             return list.get(1);
843         }
844         else {
845             return null;
846         }
847     }
848 
849     public BlogsEntry findByUUID_G(String uuid, long groupId)
850         throws NoSuchEntryException, SystemException {
851         BlogsEntry blogsEntry = fetchByUUID_G(uuid, groupId);
852 
853         if (blogsEntry == null) {
854             StringBundler msg = new StringBundler(6);
855 
856             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
857 
858             msg.append("uuid=");
859             msg.append(uuid);
860 
861             msg.append(", groupId=");
862             msg.append(groupId);
863 
864             msg.append(StringPool.CLOSE_CURLY_BRACE);
865 
866             if (_log.isWarnEnabled()) {
867                 _log.warn(msg.toString());
868             }
869 
870             throw new NoSuchEntryException(msg.toString());
871         }
872 
873         return blogsEntry;
874     }
875 
876     public BlogsEntry fetchByUUID_G(String uuid, long groupId)
877         throws SystemException {
878         return fetchByUUID_G(uuid, groupId, true);
879     }
880 
881     public BlogsEntry fetchByUUID_G(String uuid, long groupId,
882         boolean retrieveFromCache) throws SystemException {
883         Object[] finderArgs = new Object[] { uuid, groupId };
884 
885         Object result = null;
886 
887         if (retrieveFromCache) {
888             result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_UUID_G,
889                     finderArgs, this);
890         }
891 
892         if (result == null) {
893             StringBundler query = new StringBundler(4);
894 
895             query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
896 
897             if (uuid == null) {
898                 query.append(_FINDER_COLUMN_UUID_G_UUID_1);
899             }
900             else {
901                 if (uuid.equals(StringPool.BLANK)) {
902                     query.append(_FINDER_COLUMN_UUID_G_UUID_3);
903                 }
904                 else {
905                     query.append(_FINDER_COLUMN_UUID_G_UUID_2);
906                 }
907             }
908 
909             query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
910 
911             query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
912 
913             String sql = query.toString();
914 
915             Session session = null;
916 
917             try {
918                 session = openSession();
919 
920                 Query q = session.createQuery(sql);
921 
922                 QueryPos qPos = QueryPos.getInstance(q);
923 
924                 if (uuid != null) {
925                     qPos.add(uuid);
926                 }
927 
928                 qPos.add(groupId);
929 
930                 List<BlogsEntry> list = q.list();
931 
932                 result = list;
933 
934                 BlogsEntry blogsEntry = null;
935 
936                 if (list.isEmpty()) {
937                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
938                         finderArgs, list);
939                 }
940                 else {
941                     blogsEntry = list.get(0);
942 
943                     cacheResult(blogsEntry);
944 
945                     if ((blogsEntry.getUuid() == null) ||
946                             !blogsEntry.getUuid().equals(uuid) ||
947                             (blogsEntry.getGroupId() != groupId)) {
948                         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
949                             finderArgs, blogsEntry);
950                     }
951                 }
952 
953                 return blogsEntry;
954             }
955             catch (Exception e) {
956                 throw processException(e);
957             }
958             finally {
959                 if (result == null) {
960                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
961                         finderArgs, new ArrayList<BlogsEntry>());
962                 }
963 
964                 closeSession(session);
965             }
966         }
967         else {
968             if (result instanceof List<?>) {
969                 return null;
970             }
971             else {
972                 return (BlogsEntry)result;
973             }
974         }
975     }
976 
977     public List<BlogsEntry> findByGroupId(long groupId)
978         throws SystemException {
979         return findByGroupId(groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
980     }
981 
982     public List<BlogsEntry> findByGroupId(long groupId, int start, int end)
983         throws SystemException {
984         return findByGroupId(groupId, start, end, null);
985     }
986 
987     public List<BlogsEntry> findByGroupId(long groupId, int start, int end,
988         OrderByComparator orderByComparator) throws SystemException {
989         Object[] finderArgs = new Object[] {
990                 groupId,
991                 
992                 String.valueOf(start), String.valueOf(end),
993                 String.valueOf(orderByComparator)
994             };
995 
996         List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_GROUPID,
997                 finderArgs, this);
998 
999         if (list == null) {
1000            StringBundler query = null;
1001
1002            if (orderByComparator != null) {
1003                query = new StringBundler(3 +
1004                        (orderByComparator.getOrderByFields().length * 3));
1005            }
1006            else {
1007                query = new StringBundler(3);
1008            }
1009
1010            query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
1011
1012            query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1013
1014            if (orderByComparator != null) {
1015                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1016                    orderByComparator);
1017            }
1018
1019            else {
1020                query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
1021            }
1022
1023            String sql = query.toString();
1024
1025            Session session = null;
1026
1027            try {
1028                session = openSession();
1029
1030                Query q = session.createQuery(sql);
1031
1032                QueryPos qPos = QueryPos.getInstance(q);
1033
1034                qPos.add(groupId);
1035
1036                list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start,
1037                        end);
1038            }
1039            catch (Exception e) {
1040                throw processException(e);
1041            }
1042            finally {
1043                if (list == null) {
1044                    list = new ArrayList<BlogsEntry>();
1045                }
1046
1047                cacheResult(list);
1048
1049                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_GROUPID,
1050                    finderArgs, list);
1051
1052                closeSession(session);
1053            }
1054        }
1055
1056        return list;
1057    }
1058
1059    public BlogsEntry findByGroupId_First(long groupId,
1060        OrderByComparator orderByComparator)
1061        throws NoSuchEntryException, SystemException {
1062        List<BlogsEntry> list = findByGroupId(groupId, 0, 1, orderByComparator);
1063
1064        if (list.isEmpty()) {
1065            StringBundler msg = new StringBundler(4);
1066
1067            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1068
1069            msg.append("groupId=");
1070            msg.append(groupId);
1071
1072            msg.append(StringPool.CLOSE_CURLY_BRACE);
1073
1074            throw new NoSuchEntryException(msg.toString());
1075        }
1076        else {
1077            return list.get(0);
1078        }
1079    }
1080
1081    public BlogsEntry findByGroupId_Last(long groupId,
1082        OrderByComparator orderByComparator)
1083        throws NoSuchEntryException, SystemException {
1084        int count = countByGroupId(groupId);
1085
1086        List<BlogsEntry> list = findByGroupId(groupId, count - 1, count,
1087                orderByComparator);
1088
1089        if (list.isEmpty()) {
1090            StringBundler msg = new StringBundler(4);
1091
1092            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1093
1094            msg.append("groupId=");
1095            msg.append(groupId);
1096
1097            msg.append(StringPool.CLOSE_CURLY_BRACE);
1098
1099            throw new NoSuchEntryException(msg.toString());
1100        }
1101        else {
1102            return list.get(0);
1103        }
1104    }
1105
1106    public BlogsEntry[] findByGroupId_PrevAndNext(long entryId, long groupId,
1107        OrderByComparator orderByComparator)
1108        throws NoSuchEntryException, SystemException {
1109        BlogsEntry blogsEntry = findByPrimaryKey(entryId);
1110
1111        Session session = null;
1112
1113        try {
1114            session = openSession();
1115
1116            BlogsEntry[] array = new BlogsEntryImpl[3];
1117
1118            array[0] = getByGroupId_PrevAndNext(session, blogsEntry, groupId,
1119                    orderByComparator, true);
1120
1121            array[1] = blogsEntry;
1122
1123            array[2] = getByGroupId_PrevAndNext(session, blogsEntry, groupId,
1124                    orderByComparator, false);
1125
1126            return array;
1127        }
1128        catch (Exception e) {
1129            throw processException(e);
1130        }
1131        finally {
1132            closeSession(session);
1133        }
1134    }
1135
1136    protected BlogsEntry getByGroupId_PrevAndNext(Session session,
1137        BlogsEntry blogsEntry, long groupId,
1138        OrderByComparator orderByComparator, boolean previous) {
1139        StringBundler query = null;
1140
1141        if (orderByComparator != null) {
1142            query = new StringBundler(6 +
1143                    (orderByComparator.getOrderByFields().length * 6));
1144        }
1145        else {
1146            query = new StringBundler(3);
1147        }
1148
1149        query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
1150
1151        query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1152
1153        if (orderByComparator != null) {
1154            String[] orderByFields = orderByComparator.getOrderByFields();
1155
1156            if (orderByFields.length > 0) {
1157                query.append(WHERE_AND);
1158            }
1159
1160            for (int i = 0; i < orderByFields.length; i++) {
1161                query.append(_ORDER_BY_ENTITY_ALIAS);
1162                query.append(orderByFields[i]);
1163
1164                if ((i + 1) < orderByFields.length) {
1165                    if (orderByComparator.isAscending() ^ previous) {
1166                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
1167                    }
1168                    else {
1169                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
1170                    }
1171                }
1172                else {
1173                    if (orderByComparator.isAscending() ^ previous) {
1174                        query.append(WHERE_GREATER_THAN);
1175                    }
1176                    else {
1177                        query.append(WHERE_LESSER_THAN);
1178                    }
1179                }
1180            }
1181
1182            query.append(ORDER_BY_CLAUSE);
1183
1184            for (int i = 0; i < orderByFields.length; i++) {
1185                query.append(_ORDER_BY_ENTITY_ALIAS);
1186                query.append(orderByFields[i]);
1187
1188                if ((i + 1) < orderByFields.length) {
1189                    if (orderByComparator.isAscending() ^ previous) {
1190                        query.append(ORDER_BY_ASC_HAS_NEXT);
1191                    }
1192                    else {
1193                        query.append(ORDER_BY_DESC_HAS_NEXT);
1194                    }
1195                }
1196                else {
1197                    if (orderByComparator.isAscending() ^ previous) {
1198                        query.append(ORDER_BY_ASC);
1199                    }
1200                    else {
1201                        query.append(ORDER_BY_DESC);
1202                    }
1203                }
1204            }
1205        }
1206
1207        else {
1208            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
1209        }
1210
1211        String sql = query.toString();
1212
1213        Query q = session.createQuery(sql);
1214
1215        q.setFirstResult(0);
1216        q.setMaxResults(2);
1217
1218        QueryPos qPos = QueryPos.getInstance(q);
1219
1220        qPos.add(groupId);
1221
1222        if (orderByComparator != null) {
1223            Object[] values = orderByComparator.getOrderByValues(blogsEntry);
1224
1225            for (Object value : values) {
1226                qPos.add(value);
1227            }
1228        }
1229
1230        List<BlogsEntry> list = q.list();
1231
1232        if (list.size() == 2) {
1233            return list.get(1);
1234        }
1235        else {
1236            return null;
1237        }
1238    }
1239
1240    public List<BlogsEntry> findByCompanyId(long companyId)
1241        throws SystemException {
1242        return findByCompanyId(companyId, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
1243            null);
1244    }
1245
1246    public List<BlogsEntry> findByCompanyId(long companyId, int start, int end)
1247        throws SystemException {
1248        return findByCompanyId(companyId, start, end, null);
1249    }
1250
1251    public List<BlogsEntry> findByCompanyId(long companyId, int start, int end,
1252        OrderByComparator orderByComparator) throws SystemException {
1253        Object[] finderArgs = new Object[] {
1254                companyId,
1255                
1256                String.valueOf(start), String.valueOf(end),
1257                String.valueOf(orderByComparator)
1258            };
1259
1260        List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_COMPANYID,
1261                finderArgs, this);
1262
1263        if (list == null) {
1264            StringBundler query = null;
1265
1266            if (orderByComparator != null) {
1267                query = new StringBundler(3 +
1268                        (orderByComparator.getOrderByFields().length * 3));
1269            }
1270            else {
1271                query = new StringBundler(3);
1272            }
1273
1274            query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
1275
1276            query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
1277
1278            if (orderByComparator != null) {
1279                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1280                    orderByComparator);
1281            }
1282
1283            else {
1284                query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
1285            }
1286
1287            String sql = query.toString();
1288
1289            Session session = null;
1290
1291            try {
1292                session = openSession();
1293
1294                Query q = session.createQuery(sql);
1295
1296                QueryPos qPos = QueryPos.getInstance(q);
1297
1298                qPos.add(companyId);
1299
1300                list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start,
1301                        end);
1302            }
1303            catch (Exception e) {
1304                throw processException(e);
1305            }
1306            finally {
1307                if (list == null) {
1308                    list = new ArrayList<BlogsEntry>();
1309                }
1310
1311                cacheResult(list);
1312
1313                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_COMPANYID,
1314                    finderArgs, list);
1315
1316                closeSession(session);
1317            }
1318        }
1319
1320        return list;
1321    }
1322
1323    public BlogsEntry findByCompanyId_First(long companyId,
1324        OrderByComparator orderByComparator)
1325        throws NoSuchEntryException, SystemException {
1326        List<BlogsEntry> list = findByCompanyId(companyId, 0, 1,
1327                orderByComparator);
1328
1329        if (list.isEmpty()) {
1330            StringBundler msg = new StringBundler(4);
1331
1332            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1333
1334            msg.append("companyId=");
1335            msg.append(companyId);
1336
1337            msg.append(StringPool.CLOSE_CURLY_BRACE);
1338
1339            throw new NoSuchEntryException(msg.toString());
1340        }
1341        else {
1342            return list.get(0);
1343        }
1344    }
1345
1346    public BlogsEntry findByCompanyId_Last(long companyId,
1347        OrderByComparator orderByComparator)
1348        throws NoSuchEntryException, SystemException {
1349        int count = countByCompanyId(companyId);
1350
1351        List<BlogsEntry> list = findByCompanyId(companyId, count - 1, count,
1352                orderByComparator);
1353
1354        if (list.isEmpty()) {
1355            StringBundler msg = new StringBundler(4);
1356
1357            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1358
1359            msg.append("companyId=");
1360            msg.append(companyId);
1361
1362            msg.append(StringPool.CLOSE_CURLY_BRACE);
1363
1364            throw new NoSuchEntryException(msg.toString());
1365        }
1366        else {
1367            return list.get(0);
1368        }
1369    }
1370
1371    public BlogsEntry[] findByCompanyId_PrevAndNext(long entryId,
1372        long companyId, OrderByComparator orderByComparator)
1373        throws NoSuchEntryException, SystemException {
1374        BlogsEntry blogsEntry = findByPrimaryKey(entryId);
1375
1376        Session session = null;
1377
1378        try {
1379            session = openSession();
1380
1381            BlogsEntry[] array = new BlogsEntryImpl[3];
1382
1383            array[0] = getByCompanyId_PrevAndNext(session, blogsEntry,
1384                    companyId, orderByComparator, true);
1385
1386            array[1] = blogsEntry;
1387
1388            array[2] = getByCompanyId_PrevAndNext(session, blogsEntry,
1389                    companyId, orderByComparator, false);
1390
1391            return array;
1392        }
1393        catch (Exception e) {
1394            throw processException(e);
1395        }
1396        finally {
1397            closeSession(session);
1398        }
1399    }
1400
1401    protected BlogsEntry getByCompanyId_PrevAndNext(Session session,
1402        BlogsEntry blogsEntry, long companyId,
1403        OrderByComparator orderByComparator, boolean previous) {
1404        StringBundler query = null;
1405
1406        if (orderByComparator != null) {
1407            query = new StringBundler(6 +
1408                    (orderByComparator.getOrderByFields().length * 6));
1409        }
1410        else {
1411            query = new StringBundler(3);
1412        }
1413
1414        query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
1415
1416        query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
1417
1418        if (orderByComparator != null) {
1419            String[] orderByFields = orderByComparator.getOrderByFields();
1420
1421            if (orderByFields.length > 0) {
1422                query.append(WHERE_AND);
1423            }
1424
1425            for (int i = 0; i < orderByFields.length; i++) {
1426                query.append(_ORDER_BY_ENTITY_ALIAS);
1427                query.append(orderByFields[i]);
1428
1429                if ((i + 1) < orderByFields.length) {
1430                    if (orderByComparator.isAscending() ^ previous) {
1431                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
1432                    }
1433                    else {
1434                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
1435                    }
1436                }
1437                else {
1438                    if (orderByComparator.isAscending() ^ previous) {
1439                        query.append(WHERE_GREATER_THAN);
1440                    }
1441                    else {
1442                        query.append(WHERE_LESSER_THAN);
1443                    }
1444                }
1445            }
1446
1447            query.append(ORDER_BY_CLAUSE);
1448
1449            for (int i = 0; i < orderByFields.length; i++) {
1450                query.append(_ORDER_BY_ENTITY_ALIAS);
1451                query.append(orderByFields[i]);
1452
1453                if ((i + 1) < orderByFields.length) {
1454                    if (orderByComparator.isAscending() ^ previous) {
1455                        query.append(ORDER_BY_ASC_HAS_NEXT);
1456                    }
1457                    else {
1458                        query.append(ORDER_BY_DESC_HAS_NEXT);
1459                    }
1460                }
1461                else {
1462                    if (orderByComparator.isAscending() ^ previous) {
1463                        query.append(ORDER_BY_ASC);
1464                    }
1465                    else {
1466                        query.append(ORDER_BY_DESC);
1467                    }
1468                }
1469            }
1470        }
1471
1472        else {
1473            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
1474        }
1475
1476        String sql = query.toString();
1477
1478        Query q = session.createQuery(sql);
1479
1480        q.setFirstResult(0);
1481        q.setMaxResults(2);
1482
1483        QueryPos qPos = QueryPos.getInstance(q);
1484
1485        qPos.add(companyId);
1486
1487        if (orderByComparator != null) {
1488            Object[] values = orderByComparator.getOrderByValues(blogsEntry);
1489
1490            for (Object value : values) {
1491                qPos.add(value);
1492            }
1493        }
1494
1495        List<BlogsEntry> list = q.list();
1496
1497        if (list.size() == 2) {
1498            return list.get(1);
1499        }
1500        else {
1501            return null;
1502        }
1503    }
1504
1505    public List<BlogsEntry> findByG_U(long groupId, long userId)
1506        throws SystemException {
1507        return findByG_U(groupId, userId, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
1508            null);
1509    }
1510
1511    public List<BlogsEntry> findByG_U(long groupId, long userId, int start,
1512        int end) throws SystemException {
1513        return findByG_U(groupId, userId, start, end, null);
1514    }
1515
1516    public List<BlogsEntry> findByG_U(long groupId, long userId, int start,
1517        int end, OrderByComparator orderByComparator) throws SystemException {
1518        Object[] finderArgs = new Object[] {
1519                groupId, userId,
1520                
1521                String.valueOf(start), String.valueOf(end),
1522                String.valueOf(orderByComparator)
1523            };
1524
1525        List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_U,
1526                finderArgs, this);
1527
1528        if (list == null) {
1529            StringBundler query = null;
1530
1531            if (orderByComparator != null) {
1532                query = new StringBundler(4 +
1533                        (orderByComparator.getOrderByFields().length * 3));
1534            }
1535            else {
1536                query = new StringBundler(4);
1537            }
1538
1539            query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
1540
1541            query.append(_FINDER_COLUMN_G_U_GROUPID_2);
1542
1543            query.append(_FINDER_COLUMN_G_U_USERID_2);
1544
1545            if (orderByComparator != null) {
1546                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1547                    orderByComparator);
1548            }
1549
1550            else {
1551                query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
1552            }
1553
1554            String sql = query.toString();
1555
1556            Session session = null;
1557
1558            try {
1559                session = openSession();
1560
1561                Query q = session.createQuery(sql);
1562
1563                QueryPos qPos = QueryPos.getInstance(q);
1564
1565                qPos.add(groupId);
1566
1567                qPos.add(userId);
1568
1569                list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start,
1570                        end);
1571            }
1572            catch (Exception e) {
1573                throw processException(e);
1574            }
1575            finally {
1576                if (list == null) {
1577                    list = new ArrayList<BlogsEntry>();
1578                }
1579
1580                cacheResult(list);
1581
1582                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_U, finderArgs,
1583                    list);
1584
1585                closeSession(session);
1586            }
1587        }
1588
1589        return list;
1590    }
1591
1592    public BlogsEntry findByG_U_First(long groupId, long userId,
1593        OrderByComparator orderByComparator)
1594        throws NoSuchEntryException, SystemException {
1595        List<BlogsEntry> list = findByG_U(groupId, userId, 0, 1,
1596                orderByComparator);
1597
1598        if (list.isEmpty()) {
1599            StringBundler msg = new StringBundler(6);
1600
1601            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1602
1603            msg.append("groupId=");
1604            msg.append(groupId);
1605
1606            msg.append(", userId=");
1607            msg.append(userId);
1608
1609            msg.append(StringPool.CLOSE_CURLY_BRACE);
1610
1611            throw new NoSuchEntryException(msg.toString());
1612        }
1613        else {
1614            return list.get(0);
1615        }
1616    }
1617
1618    public BlogsEntry findByG_U_Last(long groupId, long userId,
1619        OrderByComparator orderByComparator)
1620        throws NoSuchEntryException, SystemException {
1621        int count = countByG_U(groupId, userId);
1622
1623        List<BlogsEntry> list = findByG_U(groupId, userId, count - 1, count,
1624                orderByComparator);
1625
1626        if (list.isEmpty()) {
1627            StringBundler msg = new StringBundler(6);
1628
1629            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1630
1631            msg.append("groupId=");
1632            msg.append(groupId);
1633
1634            msg.append(", userId=");
1635            msg.append(userId);
1636
1637            msg.append(StringPool.CLOSE_CURLY_BRACE);
1638
1639            throw new NoSuchEntryException(msg.toString());
1640        }
1641        else {
1642            return list.get(0);
1643        }
1644    }
1645
1646    public BlogsEntry[] findByG_U_PrevAndNext(long entryId, long groupId,
1647        long userId, OrderByComparator orderByComparator)
1648        throws NoSuchEntryException, SystemException {
1649        BlogsEntry blogsEntry = findByPrimaryKey(entryId);
1650
1651        Session session = null;
1652
1653        try {
1654            session = openSession();
1655
1656            BlogsEntry[] array = new BlogsEntryImpl[3];
1657
1658            array[0] = getByG_U_PrevAndNext(session, blogsEntry, groupId,
1659                    userId, orderByComparator, true);
1660
1661            array[1] = blogsEntry;
1662
1663            array[2] = getByG_U_PrevAndNext(session, blogsEntry, groupId,
1664                    userId, orderByComparator, false);
1665
1666            return array;
1667        }
1668        catch (Exception e) {
1669            throw processException(e);
1670        }
1671        finally {
1672            closeSession(session);
1673        }
1674    }
1675
1676    protected BlogsEntry getByG_U_PrevAndNext(Session session,
1677        BlogsEntry blogsEntry, long groupId, long userId,
1678        OrderByComparator orderByComparator, boolean previous) {
1679        StringBundler query = null;
1680
1681        if (orderByComparator != null) {
1682            query = new StringBundler(6 +
1683                    (orderByComparator.getOrderByFields().length * 6));
1684        }
1685        else {
1686            query = new StringBundler(3);
1687        }
1688
1689        query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
1690
1691        query.append(_FINDER_COLUMN_G_U_GROUPID_2);
1692
1693        query.append(_FINDER_COLUMN_G_U_USERID_2);
1694
1695        if (orderByComparator != null) {
1696            String[] orderByFields = orderByComparator.getOrderByFields();
1697
1698            if (orderByFields.length > 0) {
1699                query.append(WHERE_AND);
1700            }
1701
1702            for (int i = 0; i < orderByFields.length; i++) {
1703                query.append(_ORDER_BY_ENTITY_ALIAS);
1704                query.append(orderByFields[i]);
1705
1706                if ((i + 1) < orderByFields.length) {
1707                    if (orderByComparator.isAscending() ^ previous) {
1708                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
1709                    }
1710                    else {
1711                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
1712                    }
1713                }
1714                else {
1715                    if (orderByComparator.isAscending() ^ previous) {
1716                        query.append(WHERE_GREATER_THAN);
1717                    }
1718                    else {
1719                        query.append(WHERE_LESSER_THAN);
1720                    }
1721                }
1722            }
1723
1724            query.append(ORDER_BY_CLAUSE);
1725
1726            for (int i = 0; i < orderByFields.length; i++) {
1727                query.append(_ORDER_BY_ENTITY_ALIAS);
1728                query.append(orderByFields[i]);
1729
1730                if ((i + 1) < orderByFields.length) {
1731                    if (orderByComparator.isAscending() ^ previous) {
1732                        query.append(ORDER_BY_ASC_HAS_NEXT);
1733                    }
1734                    else {
1735                        query.append(ORDER_BY_DESC_HAS_NEXT);
1736                    }
1737                }
1738                else {
1739                    if (orderByComparator.isAscending() ^ previous) {
1740                        query.append(ORDER_BY_ASC);
1741                    }
1742                    else {
1743                        query.append(ORDER_BY_DESC);
1744                    }
1745                }
1746            }
1747        }
1748
1749        else {
1750            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
1751        }
1752
1753        String sql = query.toString();
1754
1755        Query q = session.createQuery(sql);
1756
1757        q.setFirstResult(0);
1758        q.setMaxResults(2);
1759
1760        QueryPos qPos = QueryPos.getInstance(q);
1761
1762        qPos.add(groupId);
1763
1764        qPos.add(userId);
1765
1766        if (orderByComparator != null) {
1767            Object[] values = orderByComparator.getOrderByValues(blogsEntry);
1768
1769            for (Object value : values) {
1770                qPos.add(value);
1771            }
1772        }
1773
1774        List<BlogsEntry> list = q.list();
1775
1776        if (list.size() == 2) {
1777            return list.get(1);
1778        }
1779        else {
1780            return null;
1781        }
1782    }
1783
1784    public BlogsEntry findByG_UT(long groupId, String urlTitle)
1785        throws NoSuchEntryException, SystemException {
1786        BlogsEntry blogsEntry = fetchByG_UT(groupId, urlTitle);
1787
1788        if (blogsEntry == null) {
1789            StringBundler msg = new StringBundler(6);
1790
1791            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1792
1793            msg.append("groupId=");
1794            msg.append(groupId);
1795
1796            msg.append(", urlTitle=");
1797            msg.append(urlTitle);
1798
1799            msg.append(StringPool.CLOSE_CURLY_BRACE);
1800
1801            if (_log.isWarnEnabled()) {
1802                _log.warn(msg.toString());
1803            }
1804
1805            throw new NoSuchEntryException(msg.toString());
1806        }
1807
1808        return blogsEntry;
1809    }
1810
1811    public BlogsEntry fetchByG_UT(long groupId, String urlTitle)
1812        throws SystemException {
1813        return fetchByG_UT(groupId, urlTitle, true);
1814    }
1815
1816    public BlogsEntry fetchByG_UT(long groupId, String urlTitle,
1817        boolean retrieveFromCache) throws SystemException {
1818        Object[] finderArgs = new Object[] { groupId, urlTitle };
1819
1820        Object result = null;
1821
1822        if (retrieveFromCache) {
1823            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_G_UT,
1824                    finderArgs, this);
1825        }
1826
1827        if (result == null) {
1828            StringBundler query = new StringBundler(4);
1829
1830            query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
1831
1832            query.append(_FINDER_COLUMN_G_UT_GROUPID_2);
1833
1834            if (urlTitle == null) {
1835                query.append(_FINDER_COLUMN_G_UT_URLTITLE_1);
1836            }
1837            else {
1838                if (urlTitle.equals(StringPool.BLANK)) {
1839                    query.append(_FINDER_COLUMN_G_UT_URLTITLE_3);
1840                }
1841                else {
1842                    query.append(_FINDER_COLUMN_G_UT_URLTITLE_2);
1843                }
1844            }
1845
1846            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
1847
1848            String sql = query.toString();
1849
1850            Session session = null;
1851
1852            try {
1853                session = openSession();
1854
1855                Query q = session.createQuery(sql);
1856
1857                QueryPos qPos = QueryPos.getInstance(q);
1858
1859                qPos.add(groupId);
1860
1861                if (urlTitle != null) {
1862                    qPos.add(urlTitle);
1863                }
1864
1865                List<BlogsEntry> list = q.list();
1866
1867                result = list;
1868
1869                BlogsEntry blogsEntry = null;
1870
1871                if (list.isEmpty()) {
1872                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_UT,
1873                        finderArgs, list);
1874                }
1875                else {
1876                    blogsEntry = list.get(0);
1877
1878                    cacheResult(blogsEntry);
1879
1880                    if ((blogsEntry.getGroupId() != groupId) ||
1881                            (blogsEntry.getUrlTitle() == null) ||
1882                            !blogsEntry.getUrlTitle().equals(urlTitle)) {
1883                        FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_UT,
1884                            finderArgs, blogsEntry);
1885                    }
1886                }
1887
1888                return blogsEntry;
1889            }
1890            catch (Exception e) {
1891                throw processException(e);
1892            }
1893            finally {
1894                if (result == null) {
1895                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_UT,
1896                        finderArgs, new ArrayList<BlogsEntry>());
1897                }
1898
1899                closeSession(session);
1900            }
1901        }
1902        else {
1903            if (result instanceof List<?>) {
1904                return null;
1905            }
1906            else {
1907                return (BlogsEntry)result;
1908            }
1909        }
1910    }
1911
1912    public List<BlogsEntry> findByG_D_D(long groupId, Date displayDate,
1913        boolean draft) throws SystemException {
1914        return findByG_D_D(groupId, displayDate, draft, QueryUtil.ALL_POS,
1915            QueryUtil.ALL_POS, null);
1916    }
1917
1918    public List<BlogsEntry> findByG_D_D(long groupId, Date displayDate,
1919        boolean draft, int start, int end) throws SystemException {
1920        return findByG_D_D(groupId, displayDate, draft, start, end, null);
1921    }
1922
1923    public List<BlogsEntry> findByG_D_D(long groupId, Date displayDate,
1924        boolean draft, int start, int end, OrderByComparator orderByComparator)
1925        throws SystemException {
1926        Object[] finderArgs = new Object[] {
1927                groupId, displayDate, draft,
1928                
1929                String.valueOf(start), String.valueOf(end),
1930                String.valueOf(orderByComparator)
1931            };
1932
1933        List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_D_D,
1934                finderArgs, this);
1935
1936        if (list == null) {
1937            StringBundler query = null;
1938
1939            if (orderByComparator != null) {
1940                query = new StringBundler(5 +
1941                        (orderByComparator.getOrderByFields().length * 3));
1942            }
1943            else {
1944                query = new StringBundler(5);
1945            }
1946
1947            query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
1948
1949            query.append(_FINDER_COLUMN_G_D_D_GROUPID_2);
1950
1951            if (displayDate == null) {
1952                query.append(_FINDER_COLUMN_G_D_D_DISPLAYDATE_1);
1953            }
1954            else {
1955                query.append(_FINDER_COLUMN_G_D_D_DISPLAYDATE_2);
1956            }
1957
1958            query.append(_FINDER_COLUMN_G_D_D_DRAFT_2);
1959
1960            if (orderByComparator != null) {
1961                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1962                    orderByComparator);
1963            }
1964
1965            else {
1966                query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
1967            }
1968
1969            String sql = query.toString();
1970
1971            Session session = null;
1972
1973            try {
1974                session = openSession();
1975
1976                Query q = session.createQuery(sql);
1977
1978                QueryPos qPos = QueryPos.getInstance(q);
1979
1980                qPos.add(groupId);
1981
1982                if (displayDate != null) {
1983                    qPos.add(CalendarUtil.getTimestamp(displayDate));
1984                }
1985
1986                qPos.add(draft);
1987
1988                list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start,
1989                        end);
1990            }
1991            catch (Exception e) {
1992                throw processException(e);
1993            }
1994            finally {
1995                if (list == null) {
1996                    list = new ArrayList<BlogsEntry>();
1997                }
1998
1999                cacheResult(list);
2000
2001                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_D_D,
2002                    finderArgs, list);
2003
2004                closeSession(session);
2005            }
2006        }
2007
2008        return list;
2009    }
2010
2011    public BlogsEntry findByG_D_D_First(long groupId, Date displayDate,
2012        boolean draft, OrderByComparator orderByComparator)
2013        throws NoSuchEntryException, SystemException {
2014        List<BlogsEntry> list = findByG_D_D(groupId, displayDate, draft, 0, 1,
2015                orderByComparator);
2016
2017        if (list.isEmpty()) {
2018            StringBundler msg = new StringBundler(8);
2019
2020            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2021
2022            msg.append("groupId=");
2023            msg.append(groupId);
2024
2025            msg.append(", displayDate=");
2026            msg.append(displayDate);
2027
2028            msg.append(", draft=");
2029            msg.append(draft);
2030
2031            msg.append(StringPool.CLOSE_CURLY_BRACE);
2032
2033            throw new NoSuchEntryException(msg.toString());
2034        }
2035        else {
2036            return list.get(0);
2037        }
2038    }
2039
2040    public BlogsEntry findByG_D_D_Last(long groupId, Date displayDate,
2041        boolean draft, OrderByComparator orderByComparator)
2042        throws NoSuchEntryException, SystemException {
2043        int count = countByG_D_D(groupId, displayDate, draft);
2044
2045        List<BlogsEntry> list = findByG_D_D(groupId, displayDate, draft,
2046                count - 1, count, orderByComparator);
2047
2048        if (list.isEmpty()) {
2049            StringBundler msg = new StringBundler(8);
2050
2051            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2052
2053            msg.append("groupId=");
2054            msg.append(groupId);
2055
2056            msg.append(", displayDate=");
2057            msg.append(displayDate);
2058
2059            msg.append(", draft=");
2060            msg.append(draft);
2061
2062            msg.append(StringPool.CLOSE_CURLY_BRACE);
2063
2064            throw new NoSuchEntryException(msg.toString());
2065        }
2066        else {
2067            return list.get(0);
2068        }
2069    }
2070
2071    public BlogsEntry[] findByG_D_D_PrevAndNext(long entryId, long groupId,
2072        Date displayDate, boolean draft, OrderByComparator orderByComparator)
2073        throws NoSuchEntryException, SystemException {
2074        BlogsEntry blogsEntry = findByPrimaryKey(entryId);
2075
2076        Session session = null;
2077
2078        try {
2079            session = openSession();
2080
2081            BlogsEntry[] array = new BlogsEntryImpl[3];
2082
2083            array[0] = getByG_D_D_PrevAndNext(session, blogsEntry, groupId,
2084                    displayDate, draft, orderByComparator, true);
2085
2086            array[1] = blogsEntry;
2087
2088            array[2] = getByG_D_D_PrevAndNext(session, blogsEntry, groupId,
2089                    displayDate, draft, orderByComparator, false);
2090
2091            return array;
2092        }
2093        catch (Exception e) {
2094            throw processException(e);
2095        }
2096        finally {
2097            closeSession(session);
2098        }
2099    }
2100
2101    protected BlogsEntry getByG_D_D_PrevAndNext(Session session,
2102        BlogsEntry blogsEntry, long groupId, Date displayDate, boolean draft,
2103        OrderByComparator orderByComparator, boolean previous) {
2104        StringBundler query = null;
2105
2106        if (orderByComparator != null) {
2107            query = new StringBundler(6 +
2108                    (orderByComparator.getOrderByFields().length * 6));
2109        }
2110        else {
2111            query = new StringBundler(3);
2112        }
2113
2114        query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
2115
2116        query.append(_FINDER_COLUMN_G_D_D_GROUPID_2);
2117
2118        if (displayDate == null) {
2119            query.append(_FINDER_COLUMN_G_D_D_DISPLAYDATE_1);
2120        }
2121        else {
2122            query.append(_FINDER_COLUMN_G_D_D_DISPLAYDATE_2);
2123        }
2124
2125        query.append(_FINDER_COLUMN_G_D_D_DRAFT_2);
2126
2127        if (orderByComparator != null) {
2128            String[] orderByFields = orderByComparator.getOrderByFields();
2129
2130            if (orderByFields.length > 0) {
2131                query.append(WHERE_AND);
2132            }
2133
2134            for (int i = 0; i < orderByFields.length; i++) {
2135                query.append(_ORDER_BY_ENTITY_ALIAS);
2136                query.append(orderByFields[i]);
2137
2138                if ((i + 1) < orderByFields.length) {
2139                    if (orderByComparator.isAscending() ^ previous) {
2140                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
2141                    }
2142                    else {
2143                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
2144                    }
2145                }
2146                else {
2147                    if (orderByComparator.isAscending() ^ previous) {
2148                        query.append(WHERE_GREATER_THAN);
2149                    }
2150                    else {
2151                        query.append(WHERE_LESSER_THAN);
2152                    }
2153                }
2154            }
2155
2156            query.append(ORDER_BY_CLAUSE);
2157
2158            for (int i = 0; i < orderByFields.length; i++) {
2159                query.append(_ORDER_BY_ENTITY_ALIAS);
2160                query.append(orderByFields[i]);
2161
2162                if ((i + 1) < orderByFields.length) {
2163                    if (orderByComparator.isAscending() ^ previous) {
2164                        query.append(ORDER_BY_ASC_HAS_NEXT);
2165                    }
2166                    else {
2167                        query.append(ORDER_BY_DESC_HAS_NEXT);
2168                    }
2169                }
2170                else {
2171                    if (orderByComparator.isAscending() ^ previous) {
2172                        query.append(ORDER_BY_ASC);
2173                    }
2174                    else {
2175                        query.append(ORDER_BY_DESC);
2176                    }
2177                }
2178            }
2179        }
2180
2181        else {
2182            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
2183        }
2184
2185        String sql = query.toString();
2186
2187        Query q = session.createQuery(sql);
2188
2189        q.setFirstResult(0);
2190        q.setMaxResults(2);
2191
2192        QueryPos qPos = QueryPos.getInstance(q);
2193
2194        qPos.add(groupId);
2195
2196        if (displayDate != null) {
2197            qPos.add(CalendarUtil.getTimestamp(displayDate));
2198        }
2199
2200        qPos.add(draft);
2201
2202        if (orderByComparator != null) {
2203            Object[] values = orderByComparator.getOrderByValues(blogsEntry);
2204
2205            for (Object value : values) {
2206                qPos.add(value);
2207            }
2208        }
2209
2210        List<BlogsEntry> list = q.list();
2211
2212        if (list.size() == 2) {
2213            return list.get(1);
2214        }
2215        else {
2216            return null;
2217        }
2218    }
2219
2220    public List<BlogsEntry> findByC_D_D(long companyId, Date displayDate,
2221        boolean draft) throws SystemException {
2222        return findByC_D_D(companyId, displayDate, draft, QueryUtil.ALL_POS,
2223            QueryUtil.ALL_POS, null);
2224    }
2225
2226    public List<BlogsEntry> findByC_D_D(long companyId, Date displayDate,
2227        boolean draft, int start, int end) throws SystemException {
2228        return findByC_D_D(companyId, displayDate, draft, start, end, null);
2229    }
2230
2231    public List<BlogsEntry> findByC_D_D(long companyId, Date displayDate,
2232        boolean draft, int start, int end, OrderByComparator orderByComparator)
2233        throws SystemException {
2234        Object[] finderArgs = new Object[] {
2235                companyId, displayDate, draft,
2236                
2237                String.valueOf(start), String.valueOf(end),
2238                String.valueOf(orderByComparator)
2239            };
2240
2241        List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_C_D_D,
2242                finderArgs, this);
2243
2244        if (list == null) {
2245            StringBundler query = null;
2246
2247            if (orderByComparator != null) {
2248                query = new StringBundler(5 +
2249                        (orderByComparator.getOrderByFields().length * 3));
2250            }
2251            else {
2252                query = new StringBundler(5);
2253            }
2254
2255            query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
2256
2257            query.append(_FINDER_COLUMN_C_D_D_COMPANYID_2);
2258
2259            if (displayDate == null) {
2260                query.append(_FINDER_COLUMN_C_D_D_DISPLAYDATE_1);
2261            }
2262            else {
2263                query.append(_FINDER_COLUMN_C_D_D_DISPLAYDATE_2);
2264            }
2265
2266            query.append(_FINDER_COLUMN_C_D_D_DRAFT_2);
2267
2268            if (orderByComparator != null) {
2269                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2270                    orderByComparator);
2271            }
2272
2273            else {
2274                query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
2275            }
2276
2277            String sql = query.toString();
2278
2279            Session session = null;
2280
2281            try {
2282                session = openSession();
2283
2284                Query q = session.createQuery(sql);
2285
2286                QueryPos qPos = QueryPos.getInstance(q);
2287
2288                qPos.add(companyId);
2289
2290                if (displayDate != null) {
2291                    qPos.add(CalendarUtil.getTimestamp(displayDate));
2292                }
2293
2294                qPos.add(draft);
2295
2296                list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start,
2297                        end);
2298            }
2299            catch (Exception e) {
2300                throw processException(e);
2301            }
2302            finally {
2303                if (list == null) {
2304                    list = new ArrayList<BlogsEntry>();
2305                }
2306
2307                cacheResult(list);
2308
2309                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_C_D_D,
2310                    finderArgs, list);
2311
2312                closeSession(session);
2313            }
2314        }
2315
2316        return list;
2317    }
2318
2319    public BlogsEntry findByC_D_D_First(long companyId, Date displayDate,
2320        boolean draft, OrderByComparator orderByComparator)
2321        throws NoSuchEntryException, SystemException {
2322        List<BlogsEntry> list = findByC_D_D(companyId, displayDate, draft, 0,
2323                1, orderByComparator);
2324
2325        if (list.isEmpty()) {
2326            StringBundler msg = new StringBundler(8);
2327
2328            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2329
2330            msg.append("companyId=");
2331            msg.append(companyId);
2332
2333            msg.append(", displayDate=");
2334            msg.append(displayDate);
2335
2336            msg.append(", draft=");
2337            msg.append(draft);
2338
2339            msg.append(StringPool.CLOSE_CURLY_BRACE);
2340
2341            throw new NoSuchEntryException(msg.toString());
2342        }
2343        else {
2344            return list.get(0);
2345        }
2346    }
2347
2348    public BlogsEntry findByC_D_D_Last(long companyId, Date displayDate,
2349        boolean draft, OrderByComparator orderByComparator)
2350        throws NoSuchEntryException, SystemException {
2351        int count = countByC_D_D(companyId, displayDate, draft);
2352
2353        List<BlogsEntry> list = findByC_D_D(companyId, displayDate, draft,
2354                count - 1, count, orderByComparator);
2355
2356        if (list.isEmpty()) {
2357            StringBundler msg = new StringBundler(8);
2358
2359            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2360
2361            msg.append("companyId=");
2362            msg.append(companyId);
2363
2364            msg.append(", displayDate=");
2365            msg.append(displayDate);
2366
2367            msg.append(", draft=");
2368            msg.append(draft);
2369
2370            msg.append(StringPool.CLOSE_CURLY_BRACE);
2371
2372            throw new NoSuchEntryException(msg.toString());
2373        }
2374        else {
2375            return list.get(0);
2376        }
2377    }
2378
2379    public BlogsEntry[] findByC_D_D_PrevAndNext(long entryId, long companyId,
2380        Date displayDate, boolean draft, OrderByComparator orderByComparator)
2381        throws NoSuchEntryException, SystemException {
2382        BlogsEntry blogsEntry = findByPrimaryKey(entryId);
2383
2384        Session session = null;
2385
2386        try {
2387            session = openSession();
2388
2389            BlogsEntry[] array = new BlogsEntryImpl[3];
2390
2391            array[0] = getByC_D_D_PrevAndNext(session, blogsEntry, companyId,
2392                    displayDate, draft, orderByComparator, true);
2393
2394            array[1] = blogsEntry;
2395
2396            array[2] = getByC_D_D_PrevAndNext(session, blogsEntry, companyId,
2397                    displayDate, draft, orderByComparator, false);
2398
2399            return array;
2400        }
2401        catch (Exception e) {
2402            throw processException(e);
2403        }
2404        finally {
2405            closeSession(session);
2406        }
2407    }
2408
2409    protected BlogsEntry getByC_D_D_PrevAndNext(Session session,
2410        BlogsEntry blogsEntry, long companyId, Date displayDate, boolean draft,
2411        OrderByComparator orderByComparator, boolean previous) {
2412        StringBundler query = null;
2413
2414        if (orderByComparator != null) {
2415            query = new StringBundler(6 +
2416                    (orderByComparator.getOrderByFields().length * 6));
2417        }
2418        else {
2419            query = new StringBundler(3);
2420        }
2421
2422        query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
2423
2424        query.append(_FINDER_COLUMN_C_D_D_COMPANYID_2);
2425
2426        if (displayDate == null) {
2427            query.append(_FINDER_COLUMN_C_D_D_DISPLAYDATE_1);
2428        }
2429        else {
2430            query.append(_FINDER_COLUMN_C_D_D_DISPLAYDATE_2);
2431        }
2432
2433        query.append(_FINDER_COLUMN_C_D_D_DRAFT_2);
2434
2435        if (orderByComparator != null) {
2436            String[] orderByFields = orderByComparator.getOrderByFields();
2437
2438            if (orderByFields.length > 0) {
2439                query.append(WHERE_AND);
2440            }
2441
2442            for (int i = 0; i < orderByFields.length; i++) {
2443                query.append(_ORDER_BY_ENTITY_ALIAS);
2444                query.append(orderByFields[i]);
2445
2446                if ((i + 1) < orderByFields.length) {
2447                    if (orderByComparator.isAscending() ^ previous) {
2448                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
2449                    }
2450                    else {
2451                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
2452                    }
2453                }
2454                else {
2455                    if (orderByComparator.isAscending() ^ previous) {
2456                        query.append(WHERE_GREATER_THAN);
2457                    }
2458                    else {
2459                        query.append(WHERE_LESSER_THAN);
2460                    }
2461                }
2462            }
2463
2464            query.append(ORDER_BY_CLAUSE);
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(ORDER_BY_ASC_HAS_NEXT);
2473                    }
2474                    else {
2475                        query.append(ORDER_BY_DESC_HAS_NEXT);
2476                    }
2477                }
2478                else {
2479                    if (orderByComparator.isAscending() ^ previous) {
2480                        query.append(ORDER_BY_ASC);
2481                    }
2482                    else {
2483                        query.append(ORDER_BY_DESC);
2484                    }
2485                }
2486            }
2487        }
2488
2489        else {
2490            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
2491        }
2492
2493        String sql = query.toString();
2494
2495        Query q = session.createQuery(sql);
2496
2497        q.setFirstResult(0);
2498        q.setMaxResults(2);
2499
2500        QueryPos qPos = QueryPos.getInstance(q);
2501
2502        qPos.add(companyId);
2503
2504        if (displayDate != null) {
2505            qPos.add(CalendarUtil.getTimestamp(displayDate));
2506        }
2507
2508        qPos.add(draft);
2509
2510        if (orderByComparator != null) {
2511            Object[] values = orderByComparator.getOrderByValues(blogsEntry);
2512
2513            for (Object value : values) {
2514                qPos.add(value);
2515            }
2516        }
2517
2518        List<BlogsEntry> list = q.list();
2519
2520        if (list.size() == 2) {
2521            return list.get(1);
2522        }
2523        else {
2524            return null;
2525        }
2526    }
2527
2528    public List<BlogsEntry> findByG_U_D_D(long groupId, long userId,
2529        Date displayDate, boolean draft) throws SystemException {
2530        return findByG_U_D_D(groupId, userId, displayDate, draft,
2531            QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
2532    }
2533
2534    public List<BlogsEntry> findByG_U_D_D(long groupId, long userId,
2535        Date displayDate, boolean draft, int start, int end)
2536        throws SystemException {
2537        return findByG_U_D_D(groupId, userId, displayDate, draft, start, end,
2538            null);
2539    }
2540
2541    public List<BlogsEntry> findByG_U_D_D(long groupId, long userId,
2542        Date displayDate, boolean draft, int start, int end,
2543        OrderByComparator orderByComparator) throws SystemException {
2544        Object[] finderArgs = new Object[] {
2545                groupId, userId, displayDate, draft,
2546                
2547                String.valueOf(start), String.valueOf(end),
2548                String.valueOf(orderByComparator)
2549            };
2550
2551        List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_U_D_D,
2552                finderArgs, this);
2553
2554        if (list == null) {
2555            StringBundler query = null;
2556
2557            if (orderByComparator != null) {
2558                query = new StringBundler(6 +
2559                        (orderByComparator.getOrderByFields().length * 3));
2560            }
2561            else {
2562                query = new StringBundler(6);
2563            }
2564
2565            query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
2566
2567            query.append(_FINDER_COLUMN_G_U_D_D_GROUPID_2);
2568
2569            query.append(_FINDER_COLUMN_G_U_D_D_USERID_2);
2570
2571            if (displayDate == null) {
2572                query.append(_FINDER_COLUMN_G_U_D_D_DISPLAYDATE_1);
2573            }
2574            else {
2575                query.append(_FINDER_COLUMN_G_U_D_D_DISPLAYDATE_2);
2576            }
2577
2578            query.append(_FINDER_COLUMN_G_U_D_D_DRAFT_2);
2579
2580            if (orderByComparator != null) {
2581                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2582                    orderByComparator);
2583            }
2584
2585            else {
2586                query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
2587            }
2588
2589            String sql = query.toString();
2590
2591            Session session = null;
2592
2593            try {
2594                session = openSession();
2595
2596                Query q = session.createQuery(sql);
2597
2598                QueryPos qPos = QueryPos.getInstance(q);
2599
2600                qPos.add(groupId);
2601
2602                qPos.add(userId);
2603
2604                if (displayDate != null) {
2605                    qPos.add(CalendarUtil.getTimestamp(displayDate));
2606                }
2607
2608                qPos.add(draft);
2609
2610                list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start,
2611                        end);
2612            }
2613            catch (Exception e) {
2614                throw processException(e);
2615            }
2616            finally {
2617                if (list == null) {
2618                    list = new ArrayList<BlogsEntry>();
2619                }
2620
2621                cacheResult(list);
2622
2623                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_U_D_D,
2624                    finderArgs, list);
2625
2626                closeSession(session);
2627            }
2628        }
2629
2630        return list;
2631    }
2632
2633    public BlogsEntry findByG_U_D_D_First(long groupId, long userId,
2634        Date displayDate, boolean draft, OrderByComparator orderByComparator)
2635        throws NoSuchEntryException, SystemException {
2636        List<BlogsEntry> list = findByG_U_D_D(groupId, userId, displayDate,
2637                draft, 0, 1, orderByComparator);
2638
2639        if (list.isEmpty()) {
2640            StringBundler msg = new StringBundler(10);
2641
2642            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2643
2644            msg.append("groupId=");
2645            msg.append(groupId);
2646
2647            msg.append(", userId=");
2648            msg.append(userId);
2649
2650            msg.append(", displayDate=");
2651            msg.append(displayDate);
2652
2653            msg.append(", draft=");
2654            msg.append(draft);
2655
2656            msg.append(StringPool.CLOSE_CURLY_BRACE);
2657
2658            throw new NoSuchEntryException(msg.toString());
2659        }
2660        else {
2661            return list.get(0);
2662        }
2663    }
2664
2665    public BlogsEntry findByG_U_D_D_Last(long groupId, long userId,
2666        Date displayDate, boolean draft, OrderByComparator orderByComparator)
2667        throws NoSuchEntryException, SystemException {
2668        int count = countByG_U_D_D(groupId, userId, displayDate, draft);
2669
2670        List<BlogsEntry> list = findByG_U_D_D(groupId, userId, displayDate,
2671                draft, count - 1, count, orderByComparator);
2672
2673        if (list.isEmpty()) {
2674            StringBundler msg = new StringBundler(10);
2675
2676            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2677
2678            msg.append("groupId=");
2679            msg.append(groupId);
2680
2681            msg.append(", userId=");
2682            msg.append(userId);
2683
2684            msg.append(", displayDate=");
2685            msg.append(displayDate);
2686
2687            msg.append(", draft=");
2688            msg.append(draft);
2689
2690            msg.append(StringPool.CLOSE_CURLY_BRACE);
2691
2692            throw new NoSuchEntryException(msg.toString());
2693        }
2694        else {
2695            return list.get(0);
2696        }
2697    }
2698
2699    public BlogsEntry[] findByG_U_D_D_PrevAndNext(long entryId, long groupId,
2700        long userId, Date displayDate, boolean draft,
2701        OrderByComparator orderByComparator)
2702        throws NoSuchEntryException, SystemException {
2703        BlogsEntry blogsEntry = findByPrimaryKey(entryId);
2704
2705        Session session = null;
2706
2707        try {
2708            session = openSession();
2709
2710            BlogsEntry[] array = new BlogsEntryImpl[3];
2711
2712            array[0] = getByG_U_D_D_PrevAndNext(session, blogsEntry, groupId,
2713                    userId, displayDate, draft, orderByComparator, true);
2714
2715            array[1] = blogsEntry;
2716
2717            array[2] = getByG_U_D_D_PrevAndNext(session, blogsEntry, groupId,
2718                    userId, displayDate, draft, orderByComparator, false);
2719
2720            return array;
2721        }
2722        catch (Exception e) {
2723            throw processException(e);
2724        }
2725        finally {
2726            closeSession(session);
2727        }
2728    }
2729
2730    protected BlogsEntry getByG_U_D_D_PrevAndNext(Session session,
2731        BlogsEntry blogsEntry, long groupId, long userId, Date displayDate,
2732        boolean draft, OrderByComparator orderByComparator, boolean previous) {
2733        StringBundler query = null;
2734
2735        if (orderByComparator != null) {
2736            query = new StringBundler(6 +
2737                    (orderByComparator.getOrderByFields().length * 6));
2738        }
2739        else {
2740            query = new StringBundler(3);
2741        }
2742
2743        query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
2744
2745        query.append(_FINDER_COLUMN_G_U_D_D_GROUPID_2);
2746
2747        query.append(_FINDER_COLUMN_G_U_D_D_USERID_2);
2748
2749        if (displayDate == null) {
2750            query.append(_FINDER_COLUMN_G_U_D_D_DISPLAYDATE_1);
2751        }
2752        else {
2753            query.append(_FINDER_COLUMN_G_U_D_D_DISPLAYDATE_2);
2754        }
2755
2756        query.append(_FINDER_COLUMN_G_U_D_D_DRAFT_2);
2757
2758        if (orderByComparator != null) {
2759            String[] orderByFields = orderByComparator.getOrderByFields();
2760
2761            if (orderByFields.length > 0) {
2762                query.append(WHERE_AND);
2763            }
2764
2765            for (int i = 0; i < orderByFields.length; i++) {
2766                query.append(_ORDER_BY_ENTITY_ALIAS);
2767                query.append(orderByFields[i]);
2768
2769                if ((i + 1) < orderByFields.length) {
2770                    if (orderByComparator.isAscending() ^ previous) {
2771                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
2772                    }
2773                    else {
2774                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
2775                    }
2776                }
2777                else {
2778                    if (orderByComparator.isAscending() ^ previous) {
2779                        query.append(WHERE_GREATER_THAN);
2780                    }
2781                    else {
2782                        query.append(WHERE_LESSER_THAN);
2783                    }
2784                }
2785            }
2786
2787            query.append(ORDER_BY_CLAUSE);
2788
2789            for (int i = 0; i < orderByFields.length; i++) {
2790                query.append(_ORDER_BY_ENTITY_ALIAS);
2791                query.append(orderByFields[i]);
2792
2793                if ((i + 1) < orderByFields.length) {
2794                    if (orderByComparator.isAscending() ^ previous) {
2795                        query.append(ORDER_BY_ASC_HAS_NEXT);
2796                    }
2797                    else {
2798                        query.append(ORDER_BY_DESC_HAS_NEXT);
2799                    }
2800                }
2801                else {
2802                    if (orderByComparator.isAscending() ^ previous) {
2803                        query.append(ORDER_BY_ASC);
2804                    }
2805                    else {
2806                        query.append(ORDER_BY_DESC);
2807                    }
2808                }
2809            }
2810        }
2811
2812        else {
2813            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
2814        }
2815
2816        String sql = query.toString();
2817
2818        Query q = session.createQuery(sql);
2819
2820        q.setFirstResult(0);
2821        q.setMaxResults(2);
2822
2823        QueryPos qPos = QueryPos.getInstance(q);
2824
2825        qPos.add(groupId);
2826
2827        qPos.add(userId);
2828
2829        if (displayDate != null) {
2830            qPos.add(CalendarUtil.getTimestamp(displayDate));
2831        }
2832
2833        qPos.add(draft);
2834
2835        if (orderByComparator != null) {
2836            Object[] values = orderByComparator.getOrderByValues(blogsEntry);
2837
2838            for (Object value : values) {
2839                qPos.add(value);
2840            }
2841        }
2842
2843        List<BlogsEntry> list = q.list();
2844
2845        if (list.size() == 2) {
2846            return list.get(1);
2847        }
2848        else {
2849            return null;
2850        }
2851    }
2852
2853    public List<BlogsEntry> findAll() throws SystemException {
2854        return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
2855    }
2856
2857    public List<BlogsEntry> findAll(int start, int end)
2858        throws SystemException {
2859        return findAll(start, end, null);
2860    }
2861
2862    public List<BlogsEntry> findAll(int start, int end,
2863        OrderByComparator orderByComparator) throws SystemException {
2864        Object[] finderArgs = new Object[] {
2865                String.valueOf(start), String.valueOf(end),
2866                String.valueOf(orderByComparator)
2867            };
2868
2869        List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
2870                finderArgs, this);
2871
2872        if (list == null) {
2873            StringBundler query = null;
2874            String sql = null;
2875
2876            if (orderByComparator != null) {
2877                query = new StringBundler(2 +
2878                        (orderByComparator.getOrderByFields().length * 3));
2879
2880                query.append(_SQL_SELECT_BLOGSENTRY);
2881
2882                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2883                    orderByComparator);
2884
2885                sql = query.toString();
2886            }
2887            else {
2888                sql = _SQL_SELECT_BLOGSENTRY.concat(BlogsEntryModelImpl.ORDER_BY_JPQL);
2889            }
2890
2891            Session session = null;
2892
2893            try {
2894                session = openSession();
2895
2896                Query q = session.createQuery(sql);
2897
2898                if (orderByComparator == null) {
2899                    list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(),
2900                            start, end, false);
2901
2902                    Collections.sort(list);
2903                }
2904                else {
2905                    list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(),
2906                            start, end);
2907                }
2908            }
2909            catch (Exception e) {
2910                throw processException(e);
2911            }
2912            finally {
2913                if (list == null) {
2914                    list = new ArrayList<BlogsEntry>();
2915                }
2916
2917                cacheResult(list);
2918
2919                FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
2920
2921                closeSession(session);
2922            }
2923        }
2924
2925        return list;
2926    }
2927
2928    public void removeByUuid(String uuid) throws SystemException {
2929        for (BlogsEntry blogsEntry : findByUuid(uuid)) {
2930            remove(blogsEntry);
2931        }
2932    }
2933
2934    public void removeByUUID_G(String uuid, long groupId)
2935        throws NoSuchEntryException, SystemException {
2936        BlogsEntry blogsEntry = findByUUID_G(uuid, groupId);
2937
2938        remove(blogsEntry);
2939    }
2940
2941    public void removeByGroupId(long groupId) throws SystemException {
2942        for (BlogsEntry blogsEntry : findByGroupId(groupId)) {
2943            remove(blogsEntry);
2944        }
2945    }
2946
2947    public void removeByCompanyId(long companyId) throws SystemException {
2948        for (BlogsEntry blogsEntry : findByCompanyId(companyId)) {
2949            remove(blogsEntry);
2950        }
2951    }
2952
2953    public void removeByG_U(long groupId, long userId)
2954        throws SystemException {
2955        for (BlogsEntry blogsEntry : findByG_U(groupId, userId)) {
2956            remove(blogsEntry);
2957        }
2958    }
2959
2960    public void removeByG_UT(long groupId, String urlTitle)
2961        throws NoSuchEntryException, SystemException {
2962        BlogsEntry blogsEntry = findByG_UT(groupId, urlTitle);
2963
2964        remove(blogsEntry);
2965    }
2966
2967    public void removeByG_D_D(long groupId, Date displayDate, boolean draft)
2968        throws SystemException {
2969        for (BlogsEntry blogsEntry : findByG_D_D(groupId, displayDate, draft)) {
2970            remove(blogsEntry);
2971        }
2972    }
2973
2974    public void removeByC_D_D(long companyId, Date displayDate, boolean draft)
2975        throws SystemException {
2976        for (BlogsEntry blogsEntry : findByC_D_D(companyId, displayDate, draft)) {
2977            remove(blogsEntry);
2978        }
2979    }
2980
2981    public void removeByG_U_D_D(long groupId, long userId, Date displayDate,
2982        boolean draft) throws SystemException {
2983        for (BlogsEntry blogsEntry : findByG_U_D_D(groupId, userId,
2984                displayDate, draft)) {
2985            remove(blogsEntry);
2986        }
2987    }
2988
2989    public void removeAll() throws SystemException {
2990        for (BlogsEntry blogsEntry : findAll()) {
2991            remove(blogsEntry);
2992        }
2993    }
2994
2995    public int countByUuid(String uuid) throws SystemException {
2996        Object[] finderArgs = new Object[] { uuid };
2997
2998        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_UUID,
2999                finderArgs, this);
3000
3001        if (count == null) {
3002            StringBundler query = new StringBundler(2);
3003
3004            query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
3005
3006            if (uuid == null) {
3007                query.append(_FINDER_COLUMN_UUID_UUID_1);
3008            }
3009            else {
3010                if (uuid.equals(StringPool.BLANK)) {
3011                    query.append(_FINDER_COLUMN_UUID_UUID_3);
3012                }
3013                else {
3014                    query.append(_FINDER_COLUMN_UUID_UUID_2);
3015                }
3016            }
3017
3018            String sql = query.toString();
3019
3020            Session session = null;
3021
3022            try {
3023                session = openSession();
3024
3025                Query q = session.createQuery(sql);
3026
3027                QueryPos qPos = QueryPos.getInstance(q);
3028
3029                if (uuid != null) {
3030                    qPos.add(uuid);
3031                }
3032
3033                count = (Long)q.uniqueResult();
3034            }
3035            catch (Exception e) {
3036                throw processException(e);
3037            }
3038            finally {
3039                if (count == null) {
3040                    count = Long.valueOf(0);
3041                }
3042
3043                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID,
3044                    finderArgs, count);
3045
3046                closeSession(session);
3047            }
3048        }
3049
3050        return count.intValue();
3051    }
3052
3053    public int countByUUID_G(String uuid, long groupId)
3054        throws SystemException {
3055        Object[] finderArgs = new Object[] { uuid, groupId };
3056
3057        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_UUID_G,
3058                finderArgs, this);
3059
3060        if (count == null) {
3061            StringBundler query = new StringBundler(3);
3062
3063            query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
3064
3065            if (uuid == null) {
3066                query.append(_FINDER_COLUMN_UUID_G_UUID_1);
3067            }
3068            else {
3069                if (uuid.equals(StringPool.BLANK)) {
3070                    query.append(_FINDER_COLUMN_UUID_G_UUID_3);
3071                }
3072                else {
3073                    query.append(_FINDER_COLUMN_UUID_G_UUID_2);
3074                }
3075            }
3076
3077            query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
3078
3079            String sql = query.toString();
3080
3081            Session session = null;
3082
3083            try {
3084                session = openSession();
3085
3086                Query q = session.createQuery(sql);
3087
3088                QueryPos qPos = QueryPos.getInstance(q);
3089
3090                if (uuid != null) {
3091                    qPos.add(uuid);
3092                }
3093
3094                qPos.add(groupId);
3095
3096                count = (Long)q.uniqueResult();
3097            }
3098            catch (Exception e) {
3099                throw processException(e);
3100            }
3101            finally {
3102                if (count == null) {
3103                    count = Long.valueOf(0);
3104                }
3105
3106                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID_G,
3107                    finderArgs, count);
3108
3109                closeSession(session);
3110            }
3111        }
3112
3113        return count.intValue();
3114    }
3115
3116    public int countByGroupId(long groupId) throws SystemException {
3117        Object[] finderArgs = new Object[] { groupId };
3118
3119        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_GROUPID,
3120                finderArgs, this);
3121
3122        if (count == null) {
3123            StringBundler query = new StringBundler(2);
3124
3125            query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
3126
3127            query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
3128
3129            String sql = query.toString();
3130
3131            Session session = null;
3132
3133            try {
3134                session = openSession();
3135
3136                Query q = session.createQuery(sql);
3137
3138                QueryPos qPos = QueryPos.getInstance(q);
3139
3140                qPos.add(groupId);
3141
3142                count = (Long)q.uniqueResult();
3143            }
3144            catch (Exception e) {
3145                throw processException(e);
3146            }
3147            finally {
3148                if (count == null) {
3149                    count = Long.valueOf(0);
3150                }
3151
3152                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_GROUPID,
3153                    finderArgs, count);
3154
3155                closeSession(session);
3156            }
3157        }
3158
3159        return count.intValue();
3160    }
3161
3162    public int countByCompanyId(long companyId) throws SystemException {
3163        Object[] finderArgs = new Object[] { companyId };
3164
3165        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_COMPANYID,
3166                finderArgs, this);
3167
3168        if (count == null) {
3169            StringBundler query = new StringBundler(2);
3170
3171            query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
3172
3173            query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
3174
3175            String sql = query.toString();
3176
3177            Session session = null;
3178
3179            try {
3180                session = openSession();
3181
3182                Query q = session.createQuery(sql);
3183
3184                QueryPos qPos = QueryPos.getInstance(q);
3185
3186                qPos.add(companyId);
3187
3188                count = (Long)q.uniqueResult();
3189            }
3190            catch (Exception e) {
3191                throw processException(e);
3192            }
3193            finally {
3194                if (count == null) {
3195                    count = Long.valueOf(0);
3196                }
3197
3198                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_COMPANYID,
3199                    finderArgs, count);
3200
3201                closeSession(session);
3202            }
3203        }
3204
3205        return count.intValue();
3206    }
3207
3208    public int countByG_U(long groupId, long userId) throws SystemException {
3209        Object[] finderArgs = new Object[] { groupId, userId };
3210
3211        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_U,
3212                finderArgs, this);
3213
3214        if (count == null) {
3215            StringBundler query = new StringBundler(3);
3216
3217            query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
3218
3219            query.append(_FINDER_COLUMN_G_U_GROUPID_2);
3220
3221            query.append(_FINDER_COLUMN_G_U_USERID_2);
3222
3223            String sql = query.toString();
3224
3225            Session session = null;
3226
3227            try {
3228                session = openSession();
3229
3230                Query q = session.createQuery(sql);
3231
3232                QueryPos qPos = QueryPos.getInstance(q);
3233
3234                qPos.add(groupId);
3235
3236                qPos.add(userId);
3237
3238                count = (Long)q.uniqueResult();
3239            }
3240            catch (Exception e) {
3241                throw processException(e);
3242            }
3243            finally {
3244                if (count == null) {
3245                    count = Long.valueOf(0);
3246                }
3247
3248                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_U, finderArgs,
3249                    count);
3250
3251                closeSession(session);
3252            }
3253        }
3254
3255        return count.intValue();
3256    }
3257
3258    public int countByG_UT(long groupId, String urlTitle)
3259        throws SystemException {
3260        Object[] finderArgs = new Object[] { groupId, urlTitle };
3261
3262        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_UT,
3263                finderArgs, this);
3264
3265        if (count == null) {
3266            StringBundler query = new StringBundler(3);
3267
3268            query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
3269
3270            query.append(_FINDER_COLUMN_G_UT_GROUPID_2);
3271
3272            if (urlTitle == null) {
3273                query.append(_FINDER_COLUMN_G_UT_URLTITLE_1);
3274            }
3275            else {
3276                if (urlTitle.equals(StringPool.BLANK)) {
3277                    query.append(_FINDER_COLUMN_G_UT_URLTITLE_3);
3278                }
3279                else {
3280                    query.append(_FINDER_COLUMN_G_UT_URLTITLE_2);
3281                }
3282            }
3283
3284            String sql = query.toString();
3285
3286            Session session = null;
3287
3288            try {
3289                session = openSession();
3290
3291                Query q = session.createQuery(sql);
3292
3293                QueryPos qPos = QueryPos.getInstance(q);
3294
3295                qPos.add(groupId);
3296
3297                if (urlTitle != null) {
3298                    qPos.add(urlTitle);
3299                }
3300
3301                count = (Long)q.uniqueResult();
3302            }
3303            catch (Exception e) {
3304                throw processException(e);
3305            }
3306            finally {
3307                if (count == null) {
3308                    count = Long.valueOf(0);
3309                }
3310
3311                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_UT,
3312                    finderArgs, count);
3313
3314                closeSession(session);
3315            }
3316        }
3317
3318        return count.intValue();
3319    }
3320
3321    public int countByG_D_D(long groupId, Date displayDate, boolean draft)
3322        throws SystemException {
3323        Object[] finderArgs = new Object[] { groupId, displayDate, draft };
3324
3325        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_D_D,
3326                finderArgs, this);
3327
3328        if (count == null) {
3329            StringBundler query = new StringBundler(4);
3330
3331            query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
3332
3333            query.append(_FINDER_COLUMN_G_D_D_GROUPID_2);
3334
3335            if (displayDate == null) {
3336                query.append(_FINDER_COLUMN_G_D_D_DISPLAYDATE_1);
3337            }
3338            else {
3339                query.append(_FINDER_COLUMN_G_D_D_DISPLAYDATE_2);
3340            }
3341
3342            query.append(_FINDER_COLUMN_G_D_D_DRAFT_2);
3343
3344            String sql = query.toString();
3345
3346            Session session = null;
3347
3348            try {
3349                session = openSession();
3350
3351                Query q = session.createQuery(sql);
3352
3353                QueryPos qPos = QueryPos.getInstance(q);
3354
3355                qPos.add(groupId);
3356
3357                if (displayDate != null) {
3358                    qPos.add(CalendarUtil.getTimestamp(displayDate));
3359                }
3360
3361                qPos.add(draft);
3362
3363                count = (Long)q.uniqueResult();
3364            }
3365            catch (Exception e) {
3366                throw processException(e);
3367            }
3368            finally {
3369                if (count == null) {
3370                    count = Long.valueOf(0);
3371                }
3372
3373                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_D_D,
3374                    finderArgs, count);
3375
3376                closeSession(session);
3377            }
3378        }
3379
3380        return count.intValue();
3381    }
3382
3383    public int countByC_D_D(long companyId, Date displayDate, boolean draft)
3384        throws SystemException {
3385        Object[] finderArgs = new Object[] { companyId, displayDate, draft };
3386
3387        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_D_D,
3388                finderArgs, this);
3389
3390        if (count == null) {
3391            StringBundler query = new StringBundler(4);
3392
3393            query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
3394
3395            query.append(_FINDER_COLUMN_C_D_D_COMPANYID_2);
3396
3397            if (displayDate == null) {
3398                query.append(_FINDER_COLUMN_C_D_D_DISPLAYDATE_1);
3399            }
3400            else {
3401                query.append(_FINDER_COLUMN_C_D_D_DISPLAYDATE_2);
3402            }
3403
3404            query.append(_FINDER_COLUMN_C_D_D_DRAFT_2);
3405
3406            String sql = query.toString();
3407
3408            Session session = null;
3409
3410            try {
3411                session = openSession();
3412
3413                Query q = session.createQuery(sql);
3414
3415                QueryPos qPos = QueryPos.getInstance(q);
3416
3417                qPos.add(companyId);
3418
3419                if (displayDate != null) {
3420                    qPos.add(CalendarUtil.getTimestamp(displayDate));
3421                }
3422
3423                qPos.add(draft);
3424
3425                count = (Long)q.uniqueResult();
3426            }
3427            catch (Exception e) {
3428                throw processException(e);
3429            }
3430            finally {
3431                if (count == null) {
3432                    count = Long.valueOf(0);
3433                }
3434
3435                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_D_D,
3436                    finderArgs, count);
3437
3438                closeSession(session);
3439            }
3440        }
3441
3442        return count.intValue();
3443    }
3444
3445    public int countByG_U_D_D(long groupId, long userId, Date displayDate,
3446        boolean draft) throws SystemException {
3447        Object[] finderArgs = new Object[] { groupId, userId, displayDate, draft };
3448
3449        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_U_D_D,
3450                finderArgs, this);
3451
3452        if (count == null) {
3453            StringBundler query = new StringBundler(5);
3454
3455            query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
3456
3457            query.append(_FINDER_COLUMN_G_U_D_D_GROUPID_2);
3458
3459            query.append(_FINDER_COLUMN_G_U_D_D_USERID_2);
3460
3461            if (displayDate == null) {
3462                query.append(_FINDER_COLUMN_G_U_D_D_DISPLAYDATE_1);
3463            }
3464            else {
3465                query.append(_FINDER_COLUMN_G_U_D_D_DISPLAYDATE_2);
3466            }
3467
3468            query.append(_FINDER_COLUMN_G_U_D_D_DRAFT_2);
3469
3470            String sql = query.toString();
3471
3472            Session session = null;
3473
3474            try {
3475                session = openSession();
3476
3477                Query q = session.createQuery(sql);
3478
3479                QueryPos qPos = QueryPos.getInstance(q);
3480
3481                qPos.add(groupId);
3482
3483                qPos.add(userId);
3484
3485                if (displayDate != null) {
3486                    qPos.add(CalendarUtil.getTimestamp(displayDate));
3487                }
3488
3489                qPos.add(draft);
3490
3491                count = (Long)q.uniqueResult();
3492            }
3493            catch (Exception e) {
3494                throw processException(e);
3495            }
3496            finally {
3497                if (count == null) {
3498                    count = Long.valueOf(0);
3499                }
3500
3501                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_U_D_D,
3502                    finderArgs, count);
3503
3504                closeSession(session);
3505            }
3506        }
3507
3508        return count.intValue();
3509    }
3510
3511    public int countAll() throws SystemException {
3512        Object[] finderArgs = new Object[0];
3513
3514        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
3515                finderArgs, this);
3516
3517        if (count == null) {
3518            Session session = null;
3519
3520            try {
3521                session = openSession();
3522
3523                Query q = session.createQuery(_SQL_COUNT_BLOGSENTRY);
3524
3525                count = (Long)q.uniqueResult();
3526            }
3527            catch (Exception e) {
3528                throw processException(e);
3529            }
3530            finally {
3531                if (count == null) {
3532                    count = Long.valueOf(0);
3533                }
3534
3535                FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
3536                    count);
3537
3538                closeSession(session);
3539            }
3540        }
3541
3542        return count.intValue();
3543    }
3544
3545    public void afterPropertiesSet() {
3546        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
3547                    com.liferay.portal.util.PropsUtil.get(
3548                        "value.object.listener.com.liferay.portlet.blogs.model.BlogsEntry")));
3549
3550        if (listenerClassNames.length > 0) {
3551            try {
3552                List<ModelListener<BlogsEntry>> listenersList = new ArrayList<ModelListener<BlogsEntry>>();
3553
3554                for (String listenerClassName : listenerClassNames) {
3555                    listenersList.add((ModelListener<BlogsEntry>)InstanceFactory.newInstance(
3556                            listenerClassName));
3557                }
3558
3559                listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
3560            }
3561            catch (Exception e) {
3562                _log.error(e);
3563            }
3564        }
3565    }
3566
3567    public void destroy() {
3568        EntityCacheUtil.removeCache(BlogsEntryImpl.class.getName());
3569        FinderCacheUtil.removeCache(FINDER_CLASS_NAME_ENTITY);
3570        FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST);
3571    }
3572
3573    @BeanReference(type = BlogsEntryPersistence.class)
3574    protected BlogsEntryPersistence blogsEntryPersistence;
3575    @BeanReference(type = BlogsStatsUserPersistence.class)
3576    protected BlogsStatsUserPersistence blogsStatsUserPersistence;
3577    @BeanReference(type = CompanyPersistence.class)
3578    protected CompanyPersistence companyPersistence;
3579    @BeanReference(type = GroupPersistence.class)
3580    protected GroupPersistence groupPersistence;
3581    @BeanReference(type = OrganizationPersistence.class)
3582    protected OrganizationPersistence organizationPersistence;
3583    @BeanReference(type = PortletPreferencesPersistence.class)
3584    protected PortletPreferencesPersistence portletPreferencesPersistence;
3585    @BeanReference(type = ResourcePersistence.class)
3586    protected ResourcePersistence resourcePersistence;
3587    @BeanReference(type = UserPersistence.class)
3588    protected UserPersistence userPersistence;
3589    @BeanReference(type = ExpandoValuePersistence.class)
3590    protected ExpandoValuePersistence expandoValuePersistence;
3591    @BeanReference(type = MBMessagePersistence.class)
3592    protected MBMessagePersistence mbMessagePersistence;
3593    @BeanReference(type = RatingsStatsPersistence.class)
3594    protected RatingsStatsPersistence ratingsStatsPersistence;
3595    @BeanReference(type = SocialActivityPersistence.class)
3596    protected SocialActivityPersistence socialActivityPersistence;
3597    @BeanReference(type = TagsAssetPersistence.class)
3598    protected TagsAssetPersistence tagsAssetPersistence;
3599    @BeanReference(type = TagsEntryPersistence.class)
3600    protected TagsEntryPersistence tagsEntryPersistence;
3601    private static final String _SQL_SELECT_BLOGSENTRY = "SELECT blogsEntry FROM BlogsEntry blogsEntry";
3602    private static final String _SQL_SELECT_BLOGSENTRY_WHERE = "SELECT blogsEntry FROM BlogsEntry blogsEntry WHERE ";
3603    private static final String _SQL_COUNT_BLOGSENTRY = "SELECT COUNT(blogsEntry) FROM BlogsEntry blogsEntry";
3604    private static final String _SQL_COUNT_BLOGSENTRY_WHERE = "SELECT COUNT(blogsEntry) FROM BlogsEntry blogsEntry WHERE ";
3605    private static final String _FINDER_COLUMN_UUID_UUID_1 = "blogsEntry.uuid IS NULL";
3606    private static final String _FINDER_COLUMN_UUID_UUID_2 = "blogsEntry.uuid = ?";
3607    private static final String _FINDER_COLUMN_UUID_UUID_3 = "(blogsEntry.uuid IS NULL OR blogsEntry.uuid = ?)";
3608    private static final String _FINDER_COLUMN_UUID_G_UUID_1 = "blogsEntry.uuid IS NULL AND ";
3609    private static final String _FINDER_COLUMN_UUID_G_UUID_2 = "blogsEntry.uuid = ? AND ";
3610    private static final String _FINDER_COLUMN_UUID_G_UUID_3 = "(blogsEntry.uuid IS NULL OR blogsEntry.uuid = ?) AND ";
3611    private static final String _FINDER_COLUMN_UUID_G_GROUPID_2 = "blogsEntry.groupId = ?";
3612    private static final String _FINDER_COLUMN_GROUPID_GROUPID_2 = "blogsEntry.groupId = ?";
3613    private static final String _FINDER_COLUMN_COMPANYID_COMPANYID_2 = "blogsEntry.companyId = ?";
3614    private static final String _FINDER_COLUMN_G_U_GROUPID_2 = "blogsEntry.groupId = ? AND ";
3615    private static final String _FINDER_COLUMN_G_U_USERID_2 = "blogsEntry.userId = ?";
3616    private static final String _FINDER_COLUMN_G_UT_GROUPID_2 = "blogsEntry.groupId = ? AND ";
3617    private static final String _FINDER_COLUMN_G_UT_URLTITLE_1 = "blogsEntry.urlTitle IS NULL";
3618    private static final String _FINDER_COLUMN_G_UT_URLTITLE_2 = "blogsEntry.urlTitle = ?";
3619    private static final String _FINDER_COLUMN_G_UT_URLTITLE_3 = "(blogsEntry.urlTitle IS NULL OR blogsEntry.urlTitle = ?)";
3620    private static final String _FINDER_COLUMN_G_D_D_GROUPID_2 = "blogsEntry.groupId = ? AND ";
3621    private static final String _FINDER_COLUMN_G_D_D_DISPLAYDATE_1 = "blogsEntry.displayDate < NULL AND ";
3622    private static final String _FINDER_COLUMN_G_D_D_DISPLAYDATE_2 = "blogsEntry.displayDate < ? AND ";
3623    private static final String _FINDER_COLUMN_G_D_D_DRAFT_2 = "blogsEntry.draft = ?";
3624    private static final String _FINDER_COLUMN_C_D_D_COMPANYID_2 = "blogsEntry.companyId = ? AND ";
3625    private static final String _FINDER_COLUMN_C_D_D_DISPLAYDATE_1 = "blogsEntry.displayDate < NULL AND ";
3626    private static final String _FINDER_COLUMN_C_D_D_DISPLAYDATE_2 = "blogsEntry.displayDate < ? AND ";
3627    private static final String _FINDER_COLUMN_C_D_D_DRAFT_2 = "blogsEntry.draft = ?";
3628    private static final String _FINDER_COLUMN_G_U_D_D_GROUPID_2 = "blogsEntry.groupId = ? AND ";
3629    private static final String _FINDER_COLUMN_G_U_D_D_USERID_2 = "blogsEntry.userId = ? AND ";
3630    private static final String _FINDER_COLUMN_G_U_D_D_DISPLAYDATE_1 = "blogsEntry.displayDate < NULL AND ";
3631    private static final String _FINDER_COLUMN_G_U_D_D_DISPLAYDATE_2 = "blogsEntry.displayDate < ? AND ";
3632    private static final String _FINDER_COLUMN_G_U_D_D_DRAFT_2 = "blogsEntry.draft = ?";
3633    private static final String _ORDER_BY_ENTITY_ALIAS = "blogsEntry.";
3634    private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No BlogsEntry exists with the primary key ";
3635    private static final String _NO_SUCH_ENTITY_WITH_KEY = "No BlogsEntry exists with the key {";
3636    private static Log _log = LogFactoryUtil.getLog(BlogsEntryPersistenceImpl.class);
3637}