1
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
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
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}