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