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