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