1
14
15 package com.liferay.portlet.journal.service.persistence;
16
17 import com.liferay.portal.NoSuchModelException;
18 import com.liferay.portal.SystemException;
19 import com.liferay.portal.kernel.annotation.BeanReference;
20 import com.liferay.portal.kernel.cache.CacheRegistry;
21 import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
22 import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
23 import com.liferay.portal.kernel.dao.orm.FinderPath;
24 import com.liferay.portal.kernel.dao.orm.Query;
25 import com.liferay.portal.kernel.dao.orm.QueryPos;
26 import com.liferay.portal.kernel.dao.orm.QueryUtil;
27 import com.liferay.portal.kernel.dao.orm.Session;
28 import com.liferay.portal.kernel.log.Log;
29 import com.liferay.portal.kernel.log.LogFactoryUtil;
30 import com.liferay.portal.kernel.util.GetterUtil;
31 import com.liferay.portal.kernel.util.InstanceFactory;
32 import com.liferay.portal.kernel.util.OrderByComparator;
33 import com.liferay.portal.kernel.util.StringBundler;
34 import com.liferay.portal.kernel.util.StringPool;
35 import com.liferay.portal.kernel.util.StringUtil;
36 import com.liferay.portal.kernel.util.Validator;
37 import com.liferay.portal.kernel.uuid.PortalUUIDUtil;
38 import com.liferay.portal.model.ModelListener;
39 import com.liferay.portal.service.persistence.BatchSessionUtil;
40 import com.liferay.portal.service.persistence.CompanyPersistence;
41 import com.liferay.portal.service.persistence.ImagePersistence;
42 import com.liferay.portal.service.persistence.PortletPreferencesPersistence;
43 import com.liferay.portal.service.persistence.ResourcePersistence;
44 import com.liferay.portal.service.persistence.UserPersistence;
45 import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
46
47 import com.liferay.portlet.expando.service.persistence.ExpandoValuePersistence;
48 import com.liferay.portlet.journal.NoSuchArticleException;
49 import com.liferay.portlet.journal.model.JournalArticle;
50 import com.liferay.portlet.journal.model.impl.JournalArticleImpl;
51 import com.liferay.portlet.journal.model.impl.JournalArticleModelImpl;
52 import com.liferay.portlet.messageboards.service.persistence.MBMessagePersistence;
53 import com.liferay.portlet.ratings.service.persistence.RatingsStatsPersistence;
54 import com.liferay.portlet.tags.service.persistence.TagsAssetPersistence;
55 import com.liferay.portlet.tags.service.persistence.TagsEntryPersistence;
56
57 import java.io.Serializable;
58
59 import java.util.ArrayList;
60 import java.util.Collections;
61 import java.util.List;
62
63
76 public class JournalArticlePersistenceImpl extends BasePersistenceImpl<JournalArticle>
77 implements JournalArticlePersistence {
78 public static final String FINDER_CLASS_NAME_ENTITY = JournalArticleImpl.class.getName();
79 public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
80 ".List";
81 public static final FinderPath FINDER_PATH_FIND_BY_UUID = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
82 JournalArticleModelImpl.FINDER_CACHE_ENABLED,
83 FINDER_CLASS_NAME_LIST, "findByUuid",
84 new String[] {
85 String.class.getName(),
86
87 "java.lang.Integer", "java.lang.Integer",
88 "com.liferay.portal.kernel.util.OrderByComparator"
89 });
90 public static final FinderPath FINDER_PATH_COUNT_BY_UUID = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
91 JournalArticleModelImpl.FINDER_CACHE_ENABLED,
92 FINDER_CLASS_NAME_LIST, "countByUuid",
93 new String[] { String.class.getName() });
94 public static final FinderPath FINDER_PATH_FETCH_BY_UUID_G = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
95 JournalArticleModelImpl.FINDER_CACHE_ENABLED,
96 FINDER_CLASS_NAME_ENTITY, "fetchByUUID_G",
97 new String[] { String.class.getName(), Long.class.getName() });
98 public static final FinderPath FINDER_PATH_COUNT_BY_UUID_G = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
99 JournalArticleModelImpl.FINDER_CACHE_ENABLED,
100 FINDER_CLASS_NAME_LIST, "countByUUID_G",
101 new String[] { String.class.getName(), Long.class.getName() });
102 public static final FinderPath FINDER_PATH_FIND_BY_GROUPID = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
103 JournalArticleModelImpl.FINDER_CACHE_ENABLED,
104 FINDER_CLASS_NAME_LIST, "findByGroupId",
105 new String[] {
106 Long.class.getName(),
107
108 "java.lang.Integer", "java.lang.Integer",
109 "com.liferay.portal.kernel.util.OrderByComparator"
110 });
111 public static final FinderPath FINDER_PATH_COUNT_BY_GROUPID = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
112 JournalArticleModelImpl.FINDER_CACHE_ENABLED,
113 FINDER_CLASS_NAME_LIST, "countByGroupId",
114 new String[] { Long.class.getName() });
115 public static final FinderPath FINDER_PATH_FIND_BY_COMPANYID = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
116 JournalArticleModelImpl.FINDER_CACHE_ENABLED,
117 FINDER_CLASS_NAME_LIST, "findByCompanyId",
118 new String[] {
119 Long.class.getName(),
120
121 "java.lang.Integer", "java.lang.Integer",
122 "com.liferay.portal.kernel.util.OrderByComparator"
123 });
124 public static final FinderPath FINDER_PATH_COUNT_BY_COMPANYID = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
125 JournalArticleModelImpl.FINDER_CACHE_ENABLED,
126 FINDER_CLASS_NAME_LIST, "countByCompanyId",
127 new String[] { Long.class.getName() });
128 public static final FinderPath FINDER_PATH_FIND_BY_SMALLIMAGEID = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
129 JournalArticleModelImpl.FINDER_CACHE_ENABLED,
130 FINDER_CLASS_NAME_LIST, "findBySmallImageId",
131 new String[] {
132 Long.class.getName(),
133
134 "java.lang.Integer", "java.lang.Integer",
135 "com.liferay.portal.kernel.util.OrderByComparator"
136 });
137 public static final FinderPath FINDER_PATH_COUNT_BY_SMALLIMAGEID = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
138 JournalArticleModelImpl.FINDER_CACHE_ENABLED,
139 FINDER_CLASS_NAME_LIST, "countBySmallImageId",
140 new String[] { Long.class.getName() });
141 public static final FinderPath FINDER_PATH_FIND_BY_R_A = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
142 JournalArticleModelImpl.FINDER_CACHE_ENABLED,
143 FINDER_CLASS_NAME_LIST, "findByR_A",
144 new String[] {
145 Long.class.getName(), Boolean.class.getName(),
146
147 "java.lang.Integer", "java.lang.Integer",
148 "com.liferay.portal.kernel.util.OrderByComparator"
149 });
150 public static final FinderPath FINDER_PATH_COUNT_BY_R_A = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
151 JournalArticleModelImpl.FINDER_CACHE_ENABLED,
152 FINDER_CLASS_NAME_LIST, "countByR_A",
153 new String[] { Long.class.getName(), Boolean.class.getName() });
154 public static final FinderPath FINDER_PATH_FIND_BY_G_A = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
155 JournalArticleModelImpl.FINDER_CACHE_ENABLED,
156 FINDER_CLASS_NAME_LIST, "findByG_A",
157 new String[] {
158 Long.class.getName(), String.class.getName(),
159
160 "java.lang.Integer", "java.lang.Integer",
161 "com.liferay.portal.kernel.util.OrderByComparator"
162 });
163 public static final FinderPath FINDER_PATH_COUNT_BY_G_A = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
164 JournalArticleModelImpl.FINDER_CACHE_ENABLED,
165 FINDER_CLASS_NAME_LIST, "countByG_A",
166 new String[] { Long.class.getName(), String.class.getName() });
167 public static final FinderPath FINDER_PATH_FIND_BY_G_S = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
168 JournalArticleModelImpl.FINDER_CACHE_ENABLED,
169 FINDER_CLASS_NAME_LIST, "findByG_S",
170 new String[] {
171 Long.class.getName(), String.class.getName(),
172
173 "java.lang.Integer", "java.lang.Integer",
174 "com.liferay.portal.kernel.util.OrderByComparator"
175 });
176 public static final FinderPath FINDER_PATH_COUNT_BY_G_S = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
177 JournalArticleModelImpl.FINDER_CACHE_ENABLED,
178 FINDER_CLASS_NAME_LIST, "countByG_S",
179 new String[] { Long.class.getName(), String.class.getName() });
180 public static final FinderPath FINDER_PATH_FIND_BY_G_T = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
181 JournalArticleModelImpl.FINDER_CACHE_ENABLED,
182 FINDER_CLASS_NAME_LIST, "findByG_T",
183 new String[] {
184 Long.class.getName(), String.class.getName(),
185
186 "java.lang.Integer", "java.lang.Integer",
187 "com.liferay.portal.kernel.util.OrderByComparator"
188 });
189 public static final FinderPath FINDER_PATH_COUNT_BY_G_T = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
190 JournalArticleModelImpl.FINDER_CACHE_ENABLED,
191 FINDER_CLASS_NAME_LIST, "countByG_T",
192 new String[] { Long.class.getName(), String.class.getName() });
193 public static final FinderPath FINDER_PATH_FIND_BY_G_UT = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
194 JournalArticleModelImpl.FINDER_CACHE_ENABLED,
195 FINDER_CLASS_NAME_LIST, "findByG_UT",
196 new String[] {
197 Long.class.getName(), String.class.getName(),
198
199 "java.lang.Integer", "java.lang.Integer",
200 "com.liferay.portal.kernel.util.OrderByComparator"
201 });
202 public static final FinderPath FINDER_PATH_COUNT_BY_G_UT = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
203 JournalArticleModelImpl.FINDER_CACHE_ENABLED,
204 FINDER_CLASS_NAME_LIST, "countByG_UT",
205 new String[] { Long.class.getName(), String.class.getName() });
206 public static final FinderPath FINDER_PATH_FETCH_BY_G_A_V = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
207 JournalArticleModelImpl.FINDER_CACHE_ENABLED,
208 FINDER_CLASS_NAME_ENTITY, "fetchByG_A_V",
209 new String[] {
210 Long.class.getName(), String.class.getName(),
211 Double.class.getName()
212 });
213 public static final FinderPath FINDER_PATH_COUNT_BY_G_A_V = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
214 JournalArticleModelImpl.FINDER_CACHE_ENABLED,
215 FINDER_CLASS_NAME_LIST, "countByG_A_V",
216 new String[] {
217 Long.class.getName(), String.class.getName(),
218 Double.class.getName()
219 });
220 public static final FinderPath FINDER_PATH_FIND_BY_G_A_A = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
221 JournalArticleModelImpl.FINDER_CACHE_ENABLED,
222 FINDER_CLASS_NAME_LIST, "findByG_A_A",
223 new String[] {
224 Long.class.getName(), String.class.getName(),
225 Boolean.class.getName(),
226
227 "java.lang.Integer", "java.lang.Integer",
228 "com.liferay.portal.kernel.util.OrderByComparator"
229 });
230 public static final FinderPath FINDER_PATH_COUNT_BY_G_A_A = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
231 JournalArticleModelImpl.FINDER_CACHE_ENABLED,
232 FINDER_CLASS_NAME_LIST, "countByG_A_A",
233 new String[] {
234 Long.class.getName(), String.class.getName(),
235 Boolean.class.getName()
236 });
237 public static final FinderPath FINDER_PATH_FIND_BY_G_UT_A = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
238 JournalArticleModelImpl.FINDER_CACHE_ENABLED,
239 FINDER_CLASS_NAME_LIST, "findByG_UT_A",
240 new String[] {
241 Long.class.getName(), String.class.getName(),
242 Boolean.class.getName(),
243
244 "java.lang.Integer", "java.lang.Integer",
245 "com.liferay.portal.kernel.util.OrderByComparator"
246 });
247 public static final FinderPath FINDER_PATH_COUNT_BY_G_UT_A = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
248 JournalArticleModelImpl.FINDER_CACHE_ENABLED,
249 FINDER_CLASS_NAME_LIST, "countByG_UT_A",
250 new String[] {
251 Long.class.getName(), String.class.getName(),
252 Boolean.class.getName()
253 });
254 public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
255 JournalArticleModelImpl.FINDER_CACHE_ENABLED,
256 FINDER_CLASS_NAME_LIST, "findAll", new String[0]);
257 public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
258 JournalArticleModelImpl.FINDER_CACHE_ENABLED,
259 FINDER_CLASS_NAME_LIST, "countAll", new String[0]);
260
261 public void cacheResult(JournalArticle journalArticle) {
262 EntityCacheUtil.putResult(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
263 JournalArticleImpl.class, journalArticle.getPrimaryKey(),
264 journalArticle);
265
266 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
267 new Object[] {
268 journalArticle.getUuid(), new Long(journalArticle.getGroupId())
269 }, journalArticle);
270
271 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A_V,
272 new Object[] {
273 new Long(journalArticle.getGroupId()),
274
275 journalArticle.getArticleId(),
276 new Double(journalArticle.getVersion())
277 }, journalArticle);
278 }
279
280 public void cacheResult(List<JournalArticle> journalArticles) {
281 for (JournalArticle journalArticle : journalArticles) {
282 if (EntityCacheUtil.getResult(
283 JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
284 JournalArticleImpl.class,
285 journalArticle.getPrimaryKey(), this) == null) {
286 cacheResult(journalArticle);
287 }
288 }
289 }
290
291 public void clearCache() {
292 CacheRegistry.clear(JournalArticleImpl.class.getName());
293 EntityCacheUtil.clearCache(JournalArticleImpl.class.getName());
294 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
295 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
296 }
297
298 public void clearCache(JournalArticle journalArticle) {
299 EntityCacheUtil.removeResult(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
300 JournalArticleImpl.class, journalArticle.getPrimaryKey());
301
302 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
303 new Object[] {
304 journalArticle.getUuid(), new Long(journalArticle.getGroupId())
305 });
306
307 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_A_V,
308 new Object[] {
309 new Long(journalArticle.getGroupId()),
310
311 journalArticle.getArticleId(),
312 new Double(journalArticle.getVersion())
313 });
314 }
315
316 public JournalArticle create(long id) {
317 JournalArticle journalArticle = new JournalArticleImpl();
318
319 journalArticle.setNew(true);
320 journalArticle.setPrimaryKey(id);
321
322 String uuid = PortalUUIDUtil.generate();
323
324 journalArticle.setUuid(uuid);
325
326 return journalArticle;
327 }
328
329 public JournalArticle remove(Serializable primaryKey)
330 throws NoSuchModelException, SystemException {
331 return remove(((Long)primaryKey).longValue());
332 }
333
334 public JournalArticle remove(long id)
335 throws NoSuchArticleException, SystemException {
336 Session session = null;
337
338 try {
339 session = openSession();
340
341 JournalArticle journalArticle = (JournalArticle)session.get(JournalArticleImpl.class,
342 new Long(id));
343
344 if (journalArticle == null) {
345 if (_log.isWarnEnabled()) {
346 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + id);
347 }
348
349 throw new NoSuchArticleException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
350 id);
351 }
352
353 return remove(journalArticle);
354 }
355 catch (NoSuchArticleException nsee) {
356 throw nsee;
357 }
358 catch (Exception e) {
359 throw processException(e);
360 }
361 finally {
362 closeSession(session);
363 }
364 }
365
366 protected JournalArticle removeImpl(JournalArticle journalArticle)
367 throws SystemException {
368 journalArticle = toUnwrappedModel(journalArticle);
369
370 Session session = null;
371
372 try {
373 session = openSession();
374
375 BatchSessionUtil.delete(session, journalArticle);
376 }
377 catch (Exception e) {
378 throw processException(e);
379 }
380 finally {
381 closeSession(session);
382 }
383
384 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
385
386 JournalArticleModelImpl journalArticleModelImpl = (JournalArticleModelImpl)journalArticle;
387
388 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
389 new Object[] {
390 journalArticleModelImpl.getOriginalUuid(),
391 new Long(journalArticleModelImpl.getOriginalGroupId())
392 });
393
394 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_A_V,
395 new Object[] {
396 new Long(journalArticleModelImpl.getOriginalGroupId()),
397
398 journalArticleModelImpl.getOriginalArticleId(),
399 new Double(journalArticleModelImpl.getOriginalVersion())
400 });
401
402 EntityCacheUtil.removeResult(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
403 JournalArticleImpl.class, journalArticle.getPrimaryKey());
404
405 return journalArticle;
406 }
407
408
411 public JournalArticle update(JournalArticle journalArticle)
412 throws SystemException {
413 if (_log.isWarnEnabled()) {
414 _log.warn(
415 "Using the deprecated update(JournalArticle journalArticle) method. Use update(JournalArticle journalArticle, boolean merge) instead.");
416 }
417
418 return update(journalArticle, false);
419 }
420
421 public JournalArticle updateImpl(
422 com.liferay.portlet.journal.model.JournalArticle journalArticle,
423 boolean merge) throws SystemException {
424 journalArticle = toUnwrappedModel(journalArticle);
425
426 boolean isNew = journalArticle.isNew();
427
428 JournalArticleModelImpl journalArticleModelImpl = (JournalArticleModelImpl)journalArticle;
429
430 if (Validator.isNull(journalArticle.getUuid())) {
431 String uuid = PortalUUIDUtil.generate();
432
433 journalArticle.setUuid(uuid);
434 }
435
436 Session session = null;
437
438 try {
439 session = openSession();
440
441 BatchSessionUtil.update(session, journalArticle, merge);
442
443 journalArticle.setNew(false);
444 }
445 catch (Exception e) {
446 throw processException(e);
447 }
448 finally {
449 closeSession(session);
450 }
451
452 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
453
454 EntityCacheUtil.putResult(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
455 JournalArticleImpl.class, journalArticle.getPrimaryKey(),
456 journalArticle);
457
458 if (!isNew &&
459 (!Validator.equals(journalArticle.getUuid(),
460 journalArticleModelImpl.getOriginalUuid()) ||
461 (journalArticle.getGroupId() != journalArticleModelImpl.getOriginalGroupId()))) {
462 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
463 new Object[] {
464 journalArticleModelImpl.getOriginalUuid(),
465 new Long(journalArticleModelImpl.getOriginalGroupId())
466 });
467 }
468
469 if (isNew ||
470 (!Validator.equals(journalArticle.getUuid(),
471 journalArticleModelImpl.getOriginalUuid()) ||
472 (journalArticle.getGroupId() != journalArticleModelImpl.getOriginalGroupId()))) {
473 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
474 new Object[] {
475 journalArticle.getUuid(),
476 new Long(journalArticle.getGroupId())
477 }, journalArticle);
478 }
479
480 if (!isNew &&
481 ((journalArticle.getGroupId() != journalArticleModelImpl.getOriginalGroupId()) ||
482 !Validator.equals(journalArticle.getArticleId(),
483 journalArticleModelImpl.getOriginalArticleId()) ||
484 (journalArticle.getVersion() != journalArticleModelImpl.getOriginalVersion()))) {
485 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_A_V,
486 new Object[] {
487 new Long(journalArticleModelImpl.getOriginalGroupId()),
488
489 journalArticleModelImpl.getOriginalArticleId(),
490 new Double(journalArticleModelImpl.getOriginalVersion())
491 });
492 }
493
494 if (isNew ||
495 ((journalArticle.getGroupId() != journalArticleModelImpl.getOriginalGroupId()) ||
496 !Validator.equals(journalArticle.getArticleId(),
497 journalArticleModelImpl.getOriginalArticleId()) ||
498 (journalArticle.getVersion() != journalArticleModelImpl.getOriginalVersion()))) {
499 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A_V,
500 new Object[] {
501 new Long(journalArticle.getGroupId()),
502
503 journalArticle.getArticleId(),
504 new Double(journalArticle.getVersion())
505 }, journalArticle);
506 }
507
508 return journalArticle;
509 }
510
511 protected JournalArticle toUnwrappedModel(JournalArticle journalArticle) {
512 if (journalArticle instanceof JournalArticleImpl) {
513 return journalArticle;
514 }
515
516 JournalArticleImpl journalArticleImpl = new JournalArticleImpl();
517
518 journalArticleImpl.setNew(journalArticle.isNew());
519 journalArticleImpl.setPrimaryKey(journalArticle.getPrimaryKey());
520
521 journalArticleImpl.setUuid(journalArticle.getUuid());
522 journalArticleImpl.setId(journalArticle.getId());
523 journalArticleImpl.setResourcePrimKey(journalArticle.getResourcePrimKey());
524 journalArticleImpl.setGroupId(journalArticle.getGroupId());
525 journalArticleImpl.setCompanyId(journalArticle.getCompanyId());
526 journalArticleImpl.setUserId(journalArticle.getUserId());
527 journalArticleImpl.setUserName(journalArticle.getUserName());
528 journalArticleImpl.setCreateDate(journalArticle.getCreateDate());
529 journalArticleImpl.setModifiedDate(journalArticle.getModifiedDate());
530 journalArticleImpl.setArticleId(journalArticle.getArticleId());
531 journalArticleImpl.setVersion(journalArticle.getVersion());
532 journalArticleImpl.setTitle(journalArticle.getTitle());
533 journalArticleImpl.setUrlTitle(journalArticle.getUrlTitle());
534 journalArticleImpl.setDescription(journalArticle.getDescription());
535 journalArticleImpl.setContent(journalArticle.getContent());
536 journalArticleImpl.setType(journalArticle.getType());
537 journalArticleImpl.setStructureId(journalArticle.getStructureId());
538 journalArticleImpl.setTemplateId(journalArticle.getTemplateId());
539 journalArticleImpl.setDisplayDate(journalArticle.getDisplayDate());
540 journalArticleImpl.setApproved(journalArticle.isApproved());
541 journalArticleImpl.setApprovedByUserId(journalArticle.getApprovedByUserId());
542 journalArticleImpl.setApprovedByUserName(journalArticle.getApprovedByUserName());
543 journalArticleImpl.setApprovedDate(journalArticle.getApprovedDate());
544 journalArticleImpl.setExpired(journalArticle.isExpired());
545 journalArticleImpl.setExpirationDate(journalArticle.getExpirationDate());
546 journalArticleImpl.setReviewDate(journalArticle.getReviewDate());
547 journalArticleImpl.setIndexable(journalArticle.isIndexable());
548 journalArticleImpl.setSmallImage(journalArticle.isSmallImage());
549 journalArticleImpl.setSmallImageId(journalArticle.getSmallImageId());
550 journalArticleImpl.setSmallImageURL(journalArticle.getSmallImageURL());
551
552 return journalArticleImpl;
553 }
554
555 public JournalArticle findByPrimaryKey(Serializable primaryKey)
556 throws NoSuchModelException, SystemException {
557 return findByPrimaryKey(((Long)primaryKey).longValue());
558 }
559
560 public JournalArticle findByPrimaryKey(long id)
561 throws NoSuchArticleException, SystemException {
562 JournalArticle journalArticle = fetchByPrimaryKey(id);
563
564 if (journalArticle == null) {
565 if (_log.isWarnEnabled()) {
566 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + id);
567 }
568
569 throw new NoSuchArticleException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
570 id);
571 }
572
573 return journalArticle;
574 }
575
576 public JournalArticle fetchByPrimaryKey(Serializable primaryKey)
577 throws SystemException {
578 return fetchByPrimaryKey(((Long)primaryKey).longValue());
579 }
580
581 public JournalArticle fetchByPrimaryKey(long id) throws SystemException {
582 JournalArticle journalArticle = (JournalArticle)EntityCacheUtil.getResult(JournalArticleModelImpl.ENTITY_CACHE_ENABLED,
583 JournalArticleImpl.class, id, this);
584
585 if (journalArticle == null) {
586 Session session = null;
587
588 try {
589 session = openSession();
590
591 journalArticle = (JournalArticle)session.get(JournalArticleImpl.class,
592 new Long(id));
593 }
594 catch (Exception e) {
595 throw processException(e);
596 }
597 finally {
598 if (journalArticle != null) {
599 cacheResult(journalArticle);
600 }
601
602 closeSession(session);
603 }
604 }
605
606 return journalArticle;
607 }
608
609 public List<JournalArticle> findByUuid(String uuid)
610 throws SystemException {
611 return findByUuid(uuid, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
612 }
613
614 public List<JournalArticle> findByUuid(String uuid, int start, int end)
615 throws SystemException {
616 return findByUuid(uuid, start, end, null);
617 }
618
619 public List<JournalArticle> findByUuid(String uuid, int start, int end,
620 OrderByComparator orderByComparator) throws SystemException {
621 Object[] finderArgs = new Object[] {
622 uuid,
623
624 String.valueOf(start), String.valueOf(end),
625 String.valueOf(orderByComparator)
626 };
627
628 List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_UUID,
629 finderArgs, this);
630
631 if (list == null) {
632 StringBundler query = null;
633
634 if (orderByComparator != null) {
635 query = new StringBundler(3 +
636 (orderByComparator.getOrderByFields().length * 3));
637 }
638 else {
639 query = new StringBundler(3);
640 }
641
642 query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
643
644 if (uuid == null) {
645 query.append(_FINDER_COLUMN_UUID_UUID_1);
646 }
647 else {
648 if (uuid.equals(StringPool.BLANK)) {
649 query.append(_FINDER_COLUMN_UUID_UUID_3);
650 }
651 else {
652 query.append(_FINDER_COLUMN_UUID_UUID_2);
653 }
654 }
655
656 if (orderByComparator != null) {
657 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
658 orderByComparator);
659 }
660
661 else {
662 query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
663 }
664
665 String sql = query.toString();
666
667 Session session = null;
668
669 try {
670 session = openSession();
671
672 Query q = session.createQuery(sql);
673
674 QueryPos qPos = QueryPos.getInstance(q);
675
676 if (uuid != null) {
677 qPos.add(uuid);
678 }
679
680 list = (List<JournalArticle>)QueryUtil.list(q, getDialect(),
681 start, end);
682 }
683 catch (Exception e) {
684 throw processException(e);
685 }
686 finally {
687 if (list == null) {
688 list = new ArrayList<JournalArticle>();
689 }
690
691 cacheResult(list);
692
693 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_UUID, finderArgs,
694 list);
695
696 closeSession(session);
697 }
698 }
699
700 return list;
701 }
702
703 public JournalArticle findByUuid_First(String uuid,
704 OrderByComparator orderByComparator)
705 throws NoSuchArticleException, SystemException {
706 List<JournalArticle> list = findByUuid(uuid, 0, 1, orderByComparator);
707
708 if (list.isEmpty()) {
709 StringBundler msg = new StringBundler(4);
710
711 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
712
713 msg.append("uuid=");
714 msg.append(uuid);
715
716 msg.append(StringPool.CLOSE_CURLY_BRACE);
717
718 throw new NoSuchArticleException(msg.toString());
719 }
720 else {
721 return list.get(0);
722 }
723 }
724
725 public JournalArticle findByUuid_Last(String uuid,
726 OrderByComparator orderByComparator)
727 throws NoSuchArticleException, SystemException {
728 int count = countByUuid(uuid);
729
730 List<JournalArticle> list = findByUuid(uuid, count - 1, count,
731 orderByComparator);
732
733 if (list.isEmpty()) {
734 StringBundler msg = new StringBundler(4);
735
736 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
737
738 msg.append("uuid=");
739 msg.append(uuid);
740
741 msg.append(StringPool.CLOSE_CURLY_BRACE);
742
743 throw new NoSuchArticleException(msg.toString());
744 }
745 else {
746 return list.get(0);
747 }
748 }
749
750 public JournalArticle[] findByUuid_PrevAndNext(long id, String uuid,
751 OrderByComparator orderByComparator)
752 throws NoSuchArticleException, SystemException {
753 JournalArticle journalArticle = findByPrimaryKey(id);
754
755 Session session = null;
756
757 try {
758 session = openSession();
759
760 JournalArticle[] array = new JournalArticleImpl[3];
761
762 array[0] = getByUuid_PrevAndNext(session, journalArticle, uuid,
763 orderByComparator, true);
764
765 array[1] = journalArticle;
766
767 array[2] = getByUuid_PrevAndNext(session, journalArticle, uuid,
768 orderByComparator, false);
769
770 return array;
771 }
772 catch (Exception e) {
773 throw processException(e);
774 }
775 finally {
776 closeSession(session);
777 }
778 }
779
780 protected JournalArticle getByUuid_PrevAndNext(Session session,
781 JournalArticle journalArticle, String uuid,
782 OrderByComparator orderByComparator, boolean previous) {
783 StringBundler query = null;
784
785 if (orderByComparator != null) {
786 query = new StringBundler(6 +
787 (orderByComparator.getOrderByFields().length * 6));
788 }
789 else {
790 query = new StringBundler(3);
791 }
792
793 query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
794
795 if (uuid == null) {
796 query.append(_FINDER_COLUMN_UUID_UUID_1);
797 }
798 else {
799 if (uuid.equals(StringPool.BLANK)) {
800 query.append(_FINDER_COLUMN_UUID_UUID_3);
801 }
802 else {
803 query.append(_FINDER_COLUMN_UUID_UUID_2);
804 }
805 }
806
807 if (orderByComparator != null) {
808 String[] orderByFields = orderByComparator.getOrderByFields();
809
810 if (orderByFields.length > 0) {
811 query.append(WHERE_AND);
812 }
813
814 for (int i = 0; i < orderByFields.length; i++) {
815 query.append(_ORDER_BY_ENTITY_ALIAS);
816 query.append(orderByFields[i]);
817
818 if ((i + 1) < orderByFields.length) {
819 if (orderByComparator.isAscending() ^ previous) {
820 query.append(WHERE_GREATER_THAN_HAS_NEXT);
821 }
822 else {
823 query.append(WHERE_LESSER_THAN_HAS_NEXT);
824 }
825 }
826 else {
827 if (orderByComparator.isAscending() ^ previous) {
828 query.append(WHERE_GREATER_THAN);
829 }
830 else {
831 query.append(WHERE_LESSER_THAN);
832 }
833 }
834 }
835
836 query.append(ORDER_BY_CLAUSE);
837
838 for (int i = 0; i < orderByFields.length; i++) {
839 query.append(_ORDER_BY_ENTITY_ALIAS);
840 query.append(orderByFields[i]);
841
842 if ((i + 1) < orderByFields.length) {
843 if (orderByComparator.isAscending() ^ previous) {
844 query.append(ORDER_BY_ASC_HAS_NEXT);
845 }
846 else {
847 query.append(ORDER_BY_DESC_HAS_NEXT);
848 }
849 }
850 else {
851 if (orderByComparator.isAscending() ^ previous) {
852 query.append(ORDER_BY_ASC);
853 }
854 else {
855 query.append(ORDER_BY_DESC);
856 }
857 }
858 }
859 }
860
861 else {
862 query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
863 }
864
865 String sql = query.toString();
866
867 Query q = session.createQuery(sql);
868
869 q.setFirstResult(0);
870 q.setMaxResults(2);
871
872 QueryPos qPos = QueryPos.getInstance(q);
873
874 if (uuid != null) {
875 qPos.add(uuid);
876 }
877
878 if (orderByComparator != null) {
879 Object[] values = orderByComparator.getOrderByValues(journalArticle);
880
881 for (Object value : values) {
882 qPos.add(value);
883 }
884 }
885
886 List<JournalArticle> list = q.list();
887
888 if (list.size() == 2) {
889 return list.get(1);
890 }
891 else {
892 return null;
893 }
894 }
895
896 public JournalArticle findByUUID_G(String uuid, long groupId)
897 throws NoSuchArticleException, SystemException {
898 JournalArticle journalArticle = fetchByUUID_G(uuid, groupId);
899
900 if (journalArticle == null) {
901 StringBundler msg = new StringBundler(6);
902
903 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
904
905 msg.append("uuid=");
906 msg.append(uuid);
907
908 msg.append(", groupId=");
909 msg.append(groupId);
910
911 msg.append(StringPool.CLOSE_CURLY_BRACE);
912
913 if (_log.isWarnEnabled()) {
914 _log.warn(msg.toString());
915 }
916
917 throw new NoSuchArticleException(msg.toString());
918 }
919
920 return journalArticle;
921 }
922
923 public JournalArticle fetchByUUID_G(String uuid, long groupId)
924 throws SystemException {
925 return fetchByUUID_G(uuid, groupId, true);
926 }
927
928 public JournalArticle fetchByUUID_G(String uuid, long groupId,
929 boolean retrieveFromCache) throws SystemException {
930 Object[] finderArgs = new Object[] { uuid, groupId };
931
932 Object result = null;
933
934 if (retrieveFromCache) {
935 result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_UUID_G,
936 finderArgs, this);
937 }
938
939 if (result == null) {
940 StringBundler query = new StringBundler(4);
941
942 query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
943
944 if (uuid == null) {
945 query.append(_FINDER_COLUMN_UUID_G_UUID_1);
946 }
947 else {
948 if (uuid.equals(StringPool.BLANK)) {
949 query.append(_FINDER_COLUMN_UUID_G_UUID_3);
950 }
951 else {
952 query.append(_FINDER_COLUMN_UUID_G_UUID_2);
953 }
954 }
955
956 query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
957
958 query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
959
960 String sql = query.toString();
961
962 Session session = null;
963
964 try {
965 session = openSession();
966
967 Query q = session.createQuery(sql);
968
969 QueryPos qPos = QueryPos.getInstance(q);
970
971 if (uuid != null) {
972 qPos.add(uuid);
973 }
974
975 qPos.add(groupId);
976
977 List<JournalArticle> list = q.list();
978
979 result = list;
980
981 JournalArticle journalArticle = null;
982
983 if (list.isEmpty()) {
984 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
985 finderArgs, list);
986 }
987 else {
988 journalArticle = list.get(0);
989
990 cacheResult(journalArticle);
991
992 if ((journalArticle.getUuid() == null) ||
993 !journalArticle.getUuid().equals(uuid) ||
994 (journalArticle.getGroupId() != groupId)) {
995 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
996 finderArgs, journalArticle);
997 }
998 }
999
1000 return journalArticle;
1001 }
1002 catch (Exception e) {
1003 throw processException(e);
1004 }
1005 finally {
1006 if (result == null) {
1007 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
1008 finderArgs, new ArrayList<JournalArticle>());
1009 }
1010
1011 closeSession(session);
1012 }
1013 }
1014 else {
1015 if (result instanceof List<?>) {
1016 return null;
1017 }
1018 else {
1019 return (JournalArticle)result;
1020 }
1021 }
1022 }
1023
1024 public List<JournalArticle> findByGroupId(long groupId)
1025 throws SystemException {
1026 return findByGroupId(groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1027 }
1028
1029 public List<JournalArticle> findByGroupId(long groupId, int start, int end)
1030 throws SystemException {
1031 return findByGroupId(groupId, start, end, null);
1032 }
1033
1034 public List<JournalArticle> findByGroupId(long groupId, int start, int end,
1035 OrderByComparator orderByComparator) throws SystemException {
1036 Object[] finderArgs = new Object[] {
1037 groupId,
1038
1039 String.valueOf(start), String.valueOf(end),
1040 String.valueOf(orderByComparator)
1041 };
1042
1043 List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_GROUPID,
1044 finderArgs, this);
1045
1046 if (list == null) {
1047 StringBundler query = null;
1048
1049 if (orderByComparator != null) {
1050 query = new StringBundler(3 +
1051 (orderByComparator.getOrderByFields().length * 3));
1052 }
1053 else {
1054 query = new StringBundler(3);
1055 }
1056
1057 query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
1058
1059 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1060
1061 if (orderByComparator != null) {
1062 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1063 orderByComparator);
1064 }
1065
1066 else {
1067 query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
1068 }
1069
1070 String sql = query.toString();
1071
1072 Session session = null;
1073
1074 try {
1075 session = openSession();
1076
1077 Query q = session.createQuery(sql);
1078
1079 QueryPos qPos = QueryPos.getInstance(q);
1080
1081 qPos.add(groupId);
1082
1083 list = (List<JournalArticle>)QueryUtil.list(q, getDialect(),
1084 start, end);
1085 }
1086 catch (Exception e) {
1087 throw processException(e);
1088 }
1089 finally {
1090 if (list == null) {
1091 list = new ArrayList<JournalArticle>();
1092 }
1093
1094 cacheResult(list);
1095
1096 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_GROUPID,
1097 finderArgs, list);
1098
1099 closeSession(session);
1100 }
1101 }
1102
1103 return list;
1104 }
1105
1106 public JournalArticle findByGroupId_First(long groupId,
1107 OrderByComparator orderByComparator)
1108 throws NoSuchArticleException, SystemException {
1109 List<JournalArticle> list = findByGroupId(groupId, 0, 1,
1110 orderByComparator);
1111
1112 if (list.isEmpty()) {
1113 StringBundler msg = new StringBundler(4);
1114
1115 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1116
1117 msg.append("groupId=");
1118 msg.append(groupId);
1119
1120 msg.append(StringPool.CLOSE_CURLY_BRACE);
1121
1122 throw new NoSuchArticleException(msg.toString());
1123 }
1124 else {
1125 return list.get(0);
1126 }
1127 }
1128
1129 public JournalArticle findByGroupId_Last(long groupId,
1130 OrderByComparator orderByComparator)
1131 throws NoSuchArticleException, SystemException {
1132 int count = countByGroupId(groupId);
1133
1134 List<JournalArticle> list = findByGroupId(groupId, count - 1, count,
1135 orderByComparator);
1136
1137 if (list.isEmpty()) {
1138 StringBundler msg = new StringBundler(4);
1139
1140 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1141
1142 msg.append("groupId=");
1143 msg.append(groupId);
1144
1145 msg.append(StringPool.CLOSE_CURLY_BRACE);
1146
1147 throw new NoSuchArticleException(msg.toString());
1148 }
1149 else {
1150 return list.get(0);
1151 }
1152 }
1153
1154 public JournalArticle[] findByGroupId_PrevAndNext(long id, long groupId,
1155 OrderByComparator orderByComparator)
1156 throws NoSuchArticleException, SystemException {
1157 JournalArticle journalArticle = findByPrimaryKey(id);
1158
1159 Session session = null;
1160
1161 try {
1162 session = openSession();
1163
1164 JournalArticle[] array = new JournalArticleImpl[3];
1165
1166 array[0] = getByGroupId_PrevAndNext(session, journalArticle,
1167 groupId, orderByComparator, true);
1168
1169 array[1] = journalArticle;
1170
1171 array[2] = getByGroupId_PrevAndNext(session, journalArticle,
1172 groupId, orderByComparator, false);
1173
1174 return array;
1175 }
1176 catch (Exception e) {
1177 throw processException(e);
1178 }
1179 finally {
1180 closeSession(session);
1181 }
1182 }
1183
1184 protected JournalArticle getByGroupId_PrevAndNext(Session session,
1185 JournalArticle journalArticle, long groupId,
1186 OrderByComparator orderByComparator, boolean previous) {
1187 StringBundler query = null;
1188
1189 if (orderByComparator != null) {
1190 query = new StringBundler(6 +
1191 (orderByComparator.getOrderByFields().length * 6));
1192 }
1193 else {
1194 query = new StringBundler(3);
1195 }
1196
1197 query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
1198
1199 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1200
1201 if (orderByComparator != null) {
1202 String[] orderByFields = orderByComparator.getOrderByFields();
1203
1204 if (orderByFields.length > 0) {
1205 query.append(WHERE_AND);
1206 }
1207
1208 for (int i = 0; i < orderByFields.length; i++) {
1209 query.append(_ORDER_BY_ENTITY_ALIAS);
1210 query.append(orderByFields[i]);
1211
1212 if ((i + 1) < orderByFields.length) {
1213 if (orderByComparator.isAscending() ^ previous) {
1214 query.append(WHERE_GREATER_THAN_HAS_NEXT);
1215 }
1216 else {
1217 query.append(WHERE_LESSER_THAN_HAS_NEXT);
1218 }
1219 }
1220 else {
1221 if (orderByComparator.isAscending() ^ previous) {
1222 query.append(WHERE_GREATER_THAN);
1223 }
1224 else {
1225 query.append(WHERE_LESSER_THAN);
1226 }
1227 }
1228 }
1229
1230 query.append(ORDER_BY_CLAUSE);
1231
1232 for (int i = 0; i < orderByFields.length; i++) {
1233 query.append(_ORDER_BY_ENTITY_ALIAS);
1234 query.append(orderByFields[i]);
1235
1236 if ((i + 1) < orderByFields.length) {
1237 if (orderByComparator.isAscending() ^ previous) {
1238 query.append(ORDER_BY_ASC_HAS_NEXT);
1239 }
1240 else {
1241 query.append(ORDER_BY_DESC_HAS_NEXT);
1242 }
1243 }
1244 else {
1245 if (orderByComparator.isAscending() ^ previous) {
1246 query.append(ORDER_BY_ASC);
1247 }
1248 else {
1249 query.append(ORDER_BY_DESC);
1250 }
1251 }
1252 }
1253 }
1254
1255 else {
1256 query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
1257 }
1258
1259 String sql = query.toString();
1260
1261 Query q = session.createQuery(sql);
1262
1263 q.setFirstResult(0);
1264 q.setMaxResults(2);
1265
1266 QueryPos qPos = QueryPos.getInstance(q);
1267
1268 qPos.add(groupId);
1269
1270 if (orderByComparator != null) {
1271 Object[] values = orderByComparator.getOrderByValues(journalArticle);
1272
1273 for (Object value : values) {
1274 qPos.add(value);
1275 }
1276 }
1277
1278 List<JournalArticle> list = q.list();
1279
1280 if (list.size() == 2) {
1281 return list.get(1);
1282 }
1283 else {
1284 return null;
1285 }
1286 }
1287
1288 public List<JournalArticle> findByCompanyId(long companyId)
1289 throws SystemException {
1290 return findByCompanyId(companyId, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
1291 null);
1292 }
1293
1294 public List<JournalArticle> findByCompanyId(long companyId, int start,
1295 int end) throws SystemException {
1296 return findByCompanyId(companyId, start, end, null);
1297 }
1298
1299 public List<JournalArticle> findByCompanyId(long companyId, int start,
1300 int end, OrderByComparator orderByComparator) throws SystemException {
1301 Object[] finderArgs = new Object[] {
1302 companyId,
1303
1304 String.valueOf(start), String.valueOf(end),
1305 String.valueOf(orderByComparator)
1306 };
1307
1308 List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_COMPANYID,
1309 finderArgs, this);
1310
1311 if (list == null) {
1312 StringBundler query = null;
1313
1314 if (orderByComparator != null) {
1315 query = new StringBundler(3 +
1316 (orderByComparator.getOrderByFields().length * 3));
1317 }
1318 else {
1319 query = new StringBundler(3);
1320 }
1321
1322 query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
1323
1324 query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
1325
1326 if (orderByComparator != null) {
1327 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1328 orderByComparator);
1329 }
1330
1331 else {
1332 query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
1333 }
1334
1335 String sql = query.toString();
1336
1337 Session session = null;
1338
1339 try {
1340 session = openSession();
1341
1342 Query q = session.createQuery(sql);
1343
1344 QueryPos qPos = QueryPos.getInstance(q);
1345
1346 qPos.add(companyId);
1347
1348 list = (List<JournalArticle>)QueryUtil.list(q, getDialect(),
1349 start, end);
1350 }
1351 catch (Exception e) {
1352 throw processException(e);
1353 }
1354 finally {
1355 if (list == null) {
1356 list = new ArrayList<JournalArticle>();
1357 }
1358
1359 cacheResult(list);
1360
1361 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_COMPANYID,
1362 finderArgs, list);
1363
1364 closeSession(session);
1365 }
1366 }
1367
1368 return list;
1369 }
1370
1371 public JournalArticle findByCompanyId_First(long companyId,
1372 OrderByComparator orderByComparator)
1373 throws NoSuchArticleException, SystemException {
1374 List<JournalArticle> list = findByCompanyId(companyId, 0, 1,
1375 orderByComparator);
1376
1377 if (list.isEmpty()) {
1378 StringBundler msg = new StringBundler(4);
1379
1380 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1381
1382 msg.append("companyId=");
1383 msg.append(companyId);
1384
1385 msg.append(StringPool.CLOSE_CURLY_BRACE);
1386
1387 throw new NoSuchArticleException(msg.toString());
1388 }
1389 else {
1390 return list.get(0);
1391 }
1392 }
1393
1394 public JournalArticle findByCompanyId_Last(long companyId,
1395 OrderByComparator orderByComparator)
1396 throws NoSuchArticleException, SystemException {
1397 int count = countByCompanyId(companyId);
1398
1399 List<JournalArticle> list = findByCompanyId(companyId, count - 1,
1400 count, orderByComparator);
1401
1402 if (list.isEmpty()) {
1403 StringBundler msg = new StringBundler(4);
1404
1405 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1406
1407 msg.append("companyId=");
1408 msg.append(companyId);
1409
1410 msg.append(StringPool.CLOSE_CURLY_BRACE);
1411
1412 throw new NoSuchArticleException(msg.toString());
1413 }
1414 else {
1415 return list.get(0);
1416 }
1417 }
1418
1419 public JournalArticle[] findByCompanyId_PrevAndNext(long id,
1420 long companyId, OrderByComparator orderByComparator)
1421 throws NoSuchArticleException, SystemException {
1422 JournalArticle journalArticle = findByPrimaryKey(id);
1423
1424 Session session = null;
1425
1426 try {
1427 session = openSession();
1428
1429 JournalArticle[] array = new JournalArticleImpl[3];
1430
1431 array[0] = getByCompanyId_PrevAndNext(session, journalArticle,
1432 companyId, orderByComparator, true);
1433
1434 array[1] = journalArticle;
1435
1436 array[2] = getByCompanyId_PrevAndNext(session, journalArticle,
1437 companyId, orderByComparator, false);
1438
1439 return array;
1440 }
1441 catch (Exception e) {
1442 throw processException(e);
1443 }
1444 finally {
1445 closeSession(session);
1446 }
1447 }
1448
1449 protected JournalArticle getByCompanyId_PrevAndNext(Session session,
1450 JournalArticle journalArticle, long companyId,
1451 OrderByComparator orderByComparator, boolean previous) {
1452 StringBundler query = null;
1453
1454 if (orderByComparator != null) {
1455 query = new StringBundler(6 +
1456 (orderByComparator.getOrderByFields().length * 6));
1457 }
1458 else {
1459 query = new StringBundler(3);
1460 }
1461
1462 query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
1463
1464 query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
1465
1466 if (orderByComparator != null) {
1467 String[] orderByFields = orderByComparator.getOrderByFields();
1468
1469 if (orderByFields.length > 0) {
1470 query.append(WHERE_AND);
1471 }
1472
1473 for (int i = 0; i < orderByFields.length; i++) {
1474 query.append(_ORDER_BY_ENTITY_ALIAS);
1475 query.append(orderByFields[i]);
1476
1477 if ((i + 1) < orderByFields.length) {
1478 if (orderByComparator.isAscending() ^ previous) {
1479 query.append(WHERE_GREATER_THAN_HAS_NEXT);
1480 }
1481 else {
1482 query.append(WHERE_LESSER_THAN_HAS_NEXT);
1483 }
1484 }
1485 else {
1486 if (orderByComparator.isAscending() ^ previous) {
1487 query.append(WHERE_GREATER_THAN);
1488 }
1489 else {
1490 query.append(WHERE_LESSER_THAN);
1491 }
1492 }
1493 }
1494
1495 query.append(ORDER_BY_CLAUSE);
1496
1497 for (int i = 0; i < orderByFields.length; i++) {
1498 query.append(_ORDER_BY_ENTITY_ALIAS);
1499 query.append(orderByFields[i]);
1500
1501 if ((i + 1) < orderByFields.length) {
1502 if (orderByComparator.isAscending() ^ previous) {
1503 query.append(ORDER_BY_ASC_HAS_NEXT);
1504 }
1505 else {
1506 query.append(ORDER_BY_DESC_HAS_NEXT);
1507 }
1508 }
1509 else {
1510 if (orderByComparator.isAscending() ^ previous) {
1511 query.append(ORDER_BY_ASC);
1512 }
1513 else {
1514 query.append(ORDER_BY_DESC);
1515 }
1516 }
1517 }
1518 }
1519
1520 else {
1521 query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
1522 }
1523
1524 String sql = query.toString();
1525
1526 Query q = session.createQuery(sql);
1527
1528 q.setFirstResult(0);
1529 q.setMaxResults(2);
1530
1531 QueryPos qPos = QueryPos.getInstance(q);
1532
1533 qPos.add(companyId);
1534
1535 if (orderByComparator != null) {
1536 Object[] values = orderByComparator.getOrderByValues(journalArticle);
1537
1538 for (Object value : values) {
1539 qPos.add(value);
1540 }
1541 }
1542
1543 List<JournalArticle> list = q.list();
1544
1545 if (list.size() == 2) {
1546 return list.get(1);
1547 }
1548 else {
1549 return null;
1550 }
1551 }
1552
1553 public List<JournalArticle> findBySmallImageId(long smallImageId)
1554 throws SystemException {
1555 return findBySmallImageId(smallImageId, QueryUtil.ALL_POS,
1556 QueryUtil.ALL_POS, null);
1557 }
1558
1559 public List<JournalArticle> findBySmallImageId(long smallImageId,
1560 int start, int end) throws SystemException {
1561 return findBySmallImageId(smallImageId, start, end, null);
1562 }
1563
1564 public List<JournalArticle> findBySmallImageId(long smallImageId,
1565 int start, int end, OrderByComparator orderByComparator)
1566 throws SystemException {
1567 Object[] finderArgs = new Object[] {
1568 smallImageId,
1569
1570 String.valueOf(start), String.valueOf(end),
1571 String.valueOf(orderByComparator)
1572 };
1573
1574 List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_SMALLIMAGEID,
1575 finderArgs, this);
1576
1577 if (list == null) {
1578 StringBundler query = null;
1579
1580 if (orderByComparator != null) {
1581 query = new StringBundler(3 +
1582 (orderByComparator.getOrderByFields().length * 3));
1583 }
1584 else {
1585 query = new StringBundler(3);
1586 }
1587
1588 query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
1589
1590 query.append(_FINDER_COLUMN_SMALLIMAGEID_SMALLIMAGEID_2);
1591
1592 if (orderByComparator != null) {
1593 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1594 orderByComparator);
1595 }
1596
1597 else {
1598 query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
1599 }
1600
1601 String sql = query.toString();
1602
1603 Session session = null;
1604
1605 try {
1606 session = openSession();
1607
1608 Query q = session.createQuery(sql);
1609
1610 QueryPos qPos = QueryPos.getInstance(q);
1611
1612 qPos.add(smallImageId);
1613
1614 list = (List<JournalArticle>)QueryUtil.list(q, getDialect(),
1615 start, end);
1616 }
1617 catch (Exception e) {
1618 throw processException(e);
1619 }
1620 finally {
1621 if (list == null) {
1622 list = new ArrayList<JournalArticle>();
1623 }
1624
1625 cacheResult(list);
1626
1627 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_SMALLIMAGEID,
1628 finderArgs, list);
1629
1630 closeSession(session);
1631 }
1632 }
1633
1634 return list;
1635 }
1636
1637 public JournalArticle findBySmallImageId_First(long smallImageId,
1638 OrderByComparator orderByComparator)
1639 throws NoSuchArticleException, SystemException {
1640 List<JournalArticle> list = findBySmallImageId(smallImageId, 0, 1,
1641 orderByComparator);
1642
1643 if (list.isEmpty()) {
1644 StringBundler msg = new StringBundler(4);
1645
1646 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1647
1648 msg.append("smallImageId=");
1649 msg.append(smallImageId);
1650
1651 msg.append(StringPool.CLOSE_CURLY_BRACE);
1652
1653 throw new NoSuchArticleException(msg.toString());
1654 }
1655 else {
1656 return list.get(0);
1657 }
1658 }
1659
1660 public JournalArticle findBySmallImageId_Last(long smallImageId,
1661 OrderByComparator orderByComparator)
1662 throws NoSuchArticleException, SystemException {
1663 int count = countBySmallImageId(smallImageId);
1664
1665 List<JournalArticle> list = findBySmallImageId(smallImageId, count - 1,
1666 count, orderByComparator);
1667
1668 if (list.isEmpty()) {
1669 StringBundler msg = new StringBundler(4);
1670
1671 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1672
1673 msg.append("smallImageId=");
1674 msg.append(smallImageId);
1675
1676 msg.append(StringPool.CLOSE_CURLY_BRACE);
1677
1678 throw new NoSuchArticleException(msg.toString());
1679 }
1680 else {
1681 return list.get(0);
1682 }
1683 }
1684
1685 public JournalArticle[] findBySmallImageId_PrevAndNext(long id,
1686 long smallImageId, OrderByComparator orderByComparator)
1687 throws NoSuchArticleException, SystemException {
1688 JournalArticle journalArticle = findByPrimaryKey(id);
1689
1690 Session session = null;
1691
1692 try {
1693 session = openSession();
1694
1695 JournalArticle[] array = new JournalArticleImpl[3];
1696
1697 array[0] = getBySmallImageId_PrevAndNext(session, journalArticle,
1698 smallImageId, orderByComparator, true);
1699
1700 array[1] = journalArticle;
1701
1702 array[2] = getBySmallImageId_PrevAndNext(session, journalArticle,
1703 smallImageId, orderByComparator, false);
1704
1705 return array;
1706 }
1707 catch (Exception e) {
1708 throw processException(e);
1709 }
1710 finally {
1711 closeSession(session);
1712 }
1713 }
1714
1715 protected JournalArticle getBySmallImageId_PrevAndNext(Session session,
1716 JournalArticle journalArticle, long smallImageId,
1717 OrderByComparator orderByComparator, boolean previous) {
1718 StringBundler query = null;
1719
1720 if (orderByComparator != null) {
1721 query = new StringBundler(6 +
1722 (orderByComparator.getOrderByFields().length * 6));
1723 }
1724 else {
1725 query = new StringBundler(3);
1726 }
1727
1728 query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
1729
1730 query.append(_FINDER_COLUMN_SMALLIMAGEID_SMALLIMAGEID_2);
1731
1732 if (orderByComparator != null) {
1733 String[] orderByFields = orderByComparator.getOrderByFields();
1734
1735 if (orderByFields.length > 0) {
1736 query.append(WHERE_AND);
1737 }
1738
1739 for (int i = 0; i < orderByFields.length; i++) {
1740 query.append(_ORDER_BY_ENTITY_ALIAS);
1741 query.append(orderByFields[i]);
1742
1743 if ((i + 1) < orderByFields.length) {
1744 if (orderByComparator.isAscending() ^ previous) {
1745 query.append(WHERE_GREATER_THAN_HAS_NEXT);
1746 }
1747 else {
1748 query.append(WHERE_LESSER_THAN_HAS_NEXT);
1749 }
1750 }
1751 else {
1752 if (orderByComparator.isAscending() ^ previous) {
1753 query.append(WHERE_GREATER_THAN);
1754 }
1755 else {
1756 query.append(WHERE_LESSER_THAN);
1757 }
1758 }
1759 }
1760
1761 query.append(ORDER_BY_CLAUSE);
1762
1763 for (int i = 0; i < orderByFields.length; i++) {
1764 query.append(_ORDER_BY_ENTITY_ALIAS);
1765 query.append(orderByFields[i]);
1766
1767 if ((i + 1) < orderByFields.length) {
1768 if (orderByComparator.isAscending() ^ previous) {
1769 query.append(ORDER_BY_ASC_HAS_NEXT);
1770 }
1771 else {
1772 query.append(ORDER_BY_DESC_HAS_NEXT);
1773 }
1774 }
1775 else {
1776 if (orderByComparator.isAscending() ^ previous) {
1777 query.append(ORDER_BY_ASC);
1778 }
1779 else {
1780 query.append(ORDER_BY_DESC);
1781 }
1782 }
1783 }
1784 }
1785
1786 else {
1787 query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
1788 }
1789
1790 String sql = query.toString();
1791
1792 Query q = session.createQuery(sql);
1793
1794 q.setFirstResult(0);
1795 q.setMaxResults(2);
1796
1797 QueryPos qPos = QueryPos.getInstance(q);
1798
1799 qPos.add(smallImageId);
1800
1801 if (orderByComparator != null) {
1802 Object[] values = orderByComparator.getOrderByValues(journalArticle);
1803
1804 for (Object value : values) {
1805 qPos.add(value);
1806 }
1807 }
1808
1809 List<JournalArticle> list = q.list();
1810
1811 if (list.size() == 2) {
1812 return list.get(1);
1813 }
1814 else {
1815 return null;
1816 }
1817 }
1818
1819 public List<JournalArticle> findByR_A(long resourcePrimKey, boolean approved)
1820 throws SystemException {
1821 return findByR_A(resourcePrimKey, approved, QueryUtil.ALL_POS,
1822 QueryUtil.ALL_POS, null);
1823 }
1824
1825 public List<JournalArticle> findByR_A(long resourcePrimKey,
1826 boolean approved, int start, int end) throws SystemException {
1827 return findByR_A(resourcePrimKey, approved, start, end, null);
1828 }
1829
1830 public List<JournalArticle> findByR_A(long resourcePrimKey,
1831 boolean approved, int start, int end,
1832 OrderByComparator orderByComparator) throws SystemException {
1833 Object[] finderArgs = new Object[] {
1834 resourcePrimKey, approved,
1835
1836 String.valueOf(start), String.valueOf(end),
1837 String.valueOf(orderByComparator)
1838 };
1839
1840 List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_R_A,
1841 finderArgs, this);
1842
1843 if (list == null) {
1844 StringBundler query = null;
1845
1846 if (orderByComparator != null) {
1847 query = new StringBundler(4 +
1848 (orderByComparator.getOrderByFields().length * 3));
1849 }
1850 else {
1851 query = new StringBundler(4);
1852 }
1853
1854 query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
1855
1856 query.append(_FINDER_COLUMN_R_A_RESOURCEPRIMKEY_2);
1857
1858 query.append(_FINDER_COLUMN_R_A_APPROVED_2);
1859
1860 if (orderByComparator != null) {
1861 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1862 orderByComparator);
1863 }
1864
1865 else {
1866 query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
1867 }
1868
1869 String sql = query.toString();
1870
1871 Session session = null;
1872
1873 try {
1874 session = openSession();
1875
1876 Query q = session.createQuery(sql);
1877
1878 QueryPos qPos = QueryPos.getInstance(q);
1879
1880 qPos.add(resourcePrimKey);
1881
1882 qPos.add(approved);
1883
1884 list = (List<JournalArticle>)QueryUtil.list(q, getDialect(),
1885 start, end);
1886 }
1887 catch (Exception e) {
1888 throw processException(e);
1889 }
1890 finally {
1891 if (list == null) {
1892 list = new ArrayList<JournalArticle>();
1893 }
1894
1895 cacheResult(list);
1896
1897 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_R_A, finderArgs,
1898 list);
1899
1900 closeSession(session);
1901 }
1902 }
1903
1904 return list;
1905 }
1906
1907 public JournalArticle findByR_A_First(long resourcePrimKey,
1908 boolean approved, OrderByComparator orderByComparator)
1909 throws NoSuchArticleException, SystemException {
1910 List<JournalArticle> list = findByR_A(resourcePrimKey, approved, 0, 1,
1911 orderByComparator);
1912
1913 if (list.isEmpty()) {
1914 StringBundler msg = new StringBundler(6);
1915
1916 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1917
1918 msg.append("resourcePrimKey=");
1919 msg.append(resourcePrimKey);
1920
1921 msg.append(", approved=");
1922 msg.append(approved);
1923
1924 msg.append(StringPool.CLOSE_CURLY_BRACE);
1925
1926 throw new NoSuchArticleException(msg.toString());
1927 }
1928 else {
1929 return list.get(0);
1930 }
1931 }
1932
1933 public JournalArticle findByR_A_Last(long resourcePrimKey,
1934 boolean approved, OrderByComparator orderByComparator)
1935 throws NoSuchArticleException, SystemException {
1936 int count = countByR_A(resourcePrimKey, approved);
1937
1938 List<JournalArticle> list = findByR_A(resourcePrimKey, approved,
1939 count - 1, count, orderByComparator);
1940
1941 if (list.isEmpty()) {
1942 StringBundler msg = new StringBundler(6);
1943
1944 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1945
1946 msg.append("resourcePrimKey=");
1947 msg.append(resourcePrimKey);
1948
1949 msg.append(", approved=");
1950 msg.append(approved);
1951
1952 msg.append(StringPool.CLOSE_CURLY_BRACE);
1953
1954 throw new NoSuchArticleException(msg.toString());
1955 }
1956 else {
1957 return list.get(0);
1958 }
1959 }
1960
1961 public JournalArticle[] findByR_A_PrevAndNext(long id,
1962 long resourcePrimKey, boolean approved,
1963 OrderByComparator orderByComparator)
1964 throws NoSuchArticleException, SystemException {
1965 JournalArticle journalArticle = findByPrimaryKey(id);
1966
1967 Session session = null;
1968
1969 try {
1970 session = openSession();
1971
1972 JournalArticle[] array = new JournalArticleImpl[3];
1973
1974 array[0] = getByR_A_PrevAndNext(session, journalArticle,
1975 resourcePrimKey, approved, orderByComparator, true);
1976
1977 array[1] = journalArticle;
1978
1979 array[2] = getByR_A_PrevAndNext(session, journalArticle,
1980 resourcePrimKey, approved, orderByComparator, false);
1981
1982 return array;
1983 }
1984 catch (Exception e) {
1985 throw processException(e);
1986 }
1987 finally {
1988 closeSession(session);
1989 }
1990 }
1991
1992 protected JournalArticle getByR_A_PrevAndNext(Session session,
1993 JournalArticle journalArticle, long resourcePrimKey, boolean approved,
1994 OrderByComparator orderByComparator, boolean previous) {
1995 StringBundler query = null;
1996
1997 if (orderByComparator != null) {
1998 query = new StringBundler(6 +
1999 (orderByComparator.getOrderByFields().length * 6));
2000 }
2001 else {
2002 query = new StringBundler(3);
2003 }
2004
2005 query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
2006
2007 query.append(_FINDER_COLUMN_R_A_RESOURCEPRIMKEY_2);
2008
2009 query.append(_FINDER_COLUMN_R_A_APPROVED_2);
2010
2011 if (orderByComparator != null) {
2012 String[] orderByFields = orderByComparator.getOrderByFields();
2013
2014 if (orderByFields.length > 0) {
2015 query.append(WHERE_AND);
2016 }
2017
2018 for (int i = 0; i < orderByFields.length; i++) {
2019 query.append(_ORDER_BY_ENTITY_ALIAS);
2020 query.append(orderByFields[i]);
2021
2022 if ((i + 1) < orderByFields.length) {
2023 if (orderByComparator.isAscending() ^ previous) {
2024 query.append(WHERE_GREATER_THAN_HAS_NEXT);
2025 }
2026 else {
2027 query.append(WHERE_LESSER_THAN_HAS_NEXT);
2028 }
2029 }
2030 else {
2031 if (orderByComparator.isAscending() ^ previous) {
2032 query.append(WHERE_GREATER_THAN);
2033 }
2034 else {
2035 query.append(WHERE_LESSER_THAN);
2036 }
2037 }
2038 }
2039
2040 query.append(ORDER_BY_CLAUSE);
2041
2042 for (int i = 0; i < orderByFields.length; i++) {
2043 query.append(_ORDER_BY_ENTITY_ALIAS);
2044 query.append(orderByFields[i]);
2045
2046 if ((i + 1) < orderByFields.length) {
2047 if (orderByComparator.isAscending() ^ previous) {
2048 query.append(ORDER_BY_ASC_HAS_NEXT);
2049 }
2050 else {
2051 query.append(ORDER_BY_DESC_HAS_NEXT);
2052 }
2053 }
2054 else {
2055 if (orderByComparator.isAscending() ^ previous) {
2056 query.append(ORDER_BY_ASC);
2057 }
2058 else {
2059 query.append(ORDER_BY_DESC);
2060 }
2061 }
2062 }
2063 }
2064
2065 else {
2066 query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
2067 }
2068
2069 String sql = query.toString();
2070
2071 Query q = session.createQuery(sql);
2072
2073 q.setFirstResult(0);
2074 q.setMaxResults(2);
2075
2076 QueryPos qPos = QueryPos.getInstance(q);
2077
2078 qPos.add(resourcePrimKey);
2079
2080 qPos.add(approved);
2081
2082 if (orderByComparator != null) {
2083 Object[] values = orderByComparator.getOrderByValues(journalArticle);
2084
2085 for (Object value : values) {
2086 qPos.add(value);
2087 }
2088 }
2089
2090 List<JournalArticle> list = q.list();
2091
2092 if (list.size() == 2) {
2093 return list.get(1);
2094 }
2095 else {
2096 return null;
2097 }
2098 }
2099
2100 public List<JournalArticle> findByG_A(long groupId, String articleId)
2101 throws SystemException {
2102 return findByG_A(groupId, articleId, QueryUtil.ALL_POS,
2103 QueryUtil.ALL_POS, null);
2104 }
2105
2106 public List<JournalArticle> findByG_A(long groupId, String articleId,
2107 int start, int end) throws SystemException {
2108 return findByG_A(groupId, articleId, start, end, null);
2109 }
2110
2111 public List<JournalArticle> findByG_A(long groupId, String articleId,
2112 int start, int end, OrderByComparator orderByComparator)
2113 throws SystemException {
2114 Object[] finderArgs = new Object[] {
2115 groupId, articleId,
2116
2117 String.valueOf(start), String.valueOf(end),
2118 String.valueOf(orderByComparator)
2119 };
2120
2121 List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_A,
2122 finderArgs, this);
2123
2124 if (list == null) {
2125 StringBundler query = null;
2126
2127 if (orderByComparator != null) {
2128 query = new StringBundler(4 +
2129 (orderByComparator.getOrderByFields().length * 3));
2130 }
2131 else {
2132 query = new StringBundler(4);
2133 }
2134
2135 query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
2136
2137 query.append(_FINDER_COLUMN_G_A_GROUPID_2);
2138
2139 if (articleId == null) {
2140 query.append(_FINDER_COLUMN_G_A_ARTICLEID_1);
2141 }
2142 else {
2143 if (articleId.equals(StringPool.BLANK)) {
2144 query.append(_FINDER_COLUMN_G_A_ARTICLEID_3);
2145 }
2146 else {
2147 query.append(_FINDER_COLUMN_G_A_ARTICLEID_2);
2148 }
2149 }
2150
2151 if (orderByComparator != null) {
2152 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2153 orderByComparator);
2154 }
2155
2156 else {
2157 query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
2158 }
2159
2160 String sql = query.toString();
2161
2162 Session session = null;
2163
2164 try {
2165 session = openSession();
2166
2167 Query q = session.createQuery(sql);
2168
2169 QueryPos qPos = QueryPos.getInstance(q);
2170
2171 qPos.add(groupId);
2172
2173 if (articleId != null) {
2174 qPos.add(articleId);
2175 }
2176
2177 list = (List<JournalArticle>)QueryUtil.list(q, getDialect(),
2178 start, end);
2179 }
2180 catch (Exception e) {
2181 throw processException(e);
2182 }
2183 finally {
2184 if (list == null) {
2185 list = new ArrayList<JournalArticle>();
2186 }
2187
2188 cacheResult(list);
2189
2190 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_A, finderArgs,
2191 list);
2192
2193 closeSession(session);
2194 }
2195 }
2196
2197 return list;
2198 }
2199
2200 public JournalArticle findByG_A_First(long groupId, String articleId,
2201 OrderByComparator orderByComparator)
2202 throws NoSuchArticleException, SystemException {
2203 List<JournalArticle> list = findByG_A(groupId, articleId, 0, 1,
2204 orderByComparator);
2205
2206 if (list.isEmpty()) {
2207 StringBundler msg = new StringBundler(6);
2208
2209 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2210
2211 msg.append("groupId=");
2212 msg.append(groupId);
2213
2214 msg.append(", articleId=");
2215 msg.append(articleId);
2216
2217 msg.append(StringPool.CLOSE_CURLY_BRACE);
2218
2219 throw new NoSuchArticleException(msg.toString());
2220 }
2221 else {
2222 return list.get(0);
2223 }
2224 }
2225
2226 public JournalArticle findByG_A_Last(long groupId, String articleId,
2227 OrderByComparator orderByComparator)
2228 throws NoSuchArticleException, SystemException {
2229 int count = countByG_A(groupId, articleId);
2230
2231 List<JournalArticle> list = findByG_A(groupId, articleId, count - 1,
2232 count, orderByComparator);
2233
2234 if (list.isEmpty()) {
2235 StringBundler msg = new StringBundler(6);
2236
2237 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2238
2239 msg.append("groupId=");
2240 msg.append(groupId);
2241
2242 msg.append(", articleId=");
2243 msg.append(articleId);
2244
2245 msg.append(StringPool.CLOSE_CURLY_BRACE);
2246
2247 throw new NoSuchArticleException(msg.toString());
2248 }
2249 else {
2250 return list.get(0);
2251 }
2252 }
2253
2254 public JournalArticle[] findByG_A_PrevAndNext(long id, long groupId,
2255 String articleId, OrderByComparator orderByComparator)
2256 throws NoSuchArticleException, SystemException {
2257 JournalArticle journalArticle = findByPrimaryKey(id);
2258
2259 Session session = null;
2260
2261 try {
2262 session = openSession();
2263
2264 JournalArticle[] array = new JournalArticleImpl[3];
2265
2266 array[0] = getByG_A_PrevAndNext(session, journalArticle, groupId,
2267 articleId, orderByComparator, true);
2268
2269 array[1] = journalArticle;
2270
2271 array[2] = getByG_A_PrevAndNext(session, journalArticle, groupId,
2272 articleId, orderByComparator, false);
2273
2274 return array;
2275 }
2276 catch (Exception e) {
2277 throw processException(e);
2278 }
2279 finally {
2280 closeSession(session);
2281 }
2282 }
2283
2284 protected JournalArticle getByG_A_PrevAndNext(Session session,
2285 JournalArticle journalArticle, long groupId, String articleId,
2286 OrderByComparator orderByComparator, boolean previous) {
2287 StringBundler query = null;
2288
2289 if (orderByComparator != null) {
2290 query = new StringBundler(6 +
2291 (orderByComparator.getOrderByFields().length * 6));
2292 }
2293 else {
2294 query = new StringBundler(3);
2295 }
2296
2297 query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
2298
2299 query.append(_FINDER_COLUMN_G_A_GROUPID_2);
2300
2301 if (articleId == null) {
2302 query.append(_FINDER_COLUMN_G_A_ARTICLEID_1);
2303 }
2304 else {
2305 if (articleId.equals(StringPool.BLANK)) {
2306 query.append(_FINDER_COLUMN_G_A_ARTICLEID_3);
2307 }
2308 else {
2309 query.append(_FINDER_COLUMN_G_A_ARTICLEID_2);
2310 }
2311 }
2312
2313 if (orderByComparator != null) {
2314 String[] orderByFields = orderByComparator.getOrderByFields();
2315
2316 if (orderByFields.length > 0) {
2317 query.append(WHERE_AND);
2318 }
2319
2320 for (int i = 0; i < orderByFields.length; i++) {
2321 query.append(_ORDER_BY_ENTITY_ALIAS);
2322 query.append(orderByFields[i]);
2323
2324 if ((i + 1) < orderByFields.length) {
2325 if (orderByComparator.isAscending() ^ previous) {
2326 query.append(WHERE_GREATER_THAN_HAS_NEXT);
2327 }
2328 else {
2329 query.append(WHERE_LESSER_THAN_HAS_NEXT);
2330 }
2331 }
2332 else {
2333 if (orderByComparator.isAscending() ^ previous) {
2334 query.append(WHERE_GREATER_THAN);
2335 }
2336 else {
2337 query.append(WHERE_LESSER_THAN);
2338 }
2339 }
2340 }
2341
2342 query.append(ORDER_BY_CLAUSE);
2343
2344 for (int i = 0; i < orderByFields.length; i++) {
2345 query.append(_ORDER_BY_ENTITY_ALIAS);
2346 query.append(orderByFields[i]);
2347
2348 if ((i + 1) < orderByFields.length) {
2349 if (orderByComparator.isAscending() ^ previous) {
2350 query.append(ORDER_BY_ASC_HAS_NEXT);
2351 }
2352 else {
2353 query.append(ORDER_BY_DESC_HAS_NEXT);
2354 }
2355 }
2356 else {
2357 if (orderByComparator.isAscending() ^ previous) {
2358 query.append(ORDER_BY_ASC);
2359 }
2360 else {
2361 query.append(ORDER_BY_DESC);
2362 }
2363 }
2364 }
2365 }
2366
2367 else {
2368 query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
2369 }
2370
2371 String sql = query.toString();
2372
2373 Query q = session.createQuery(sql);
2374
2375 q.setFirstResult(0);
2376 q.setMaxResults(2);
2377
2378 QueryPos qPos = QueryPos.getInstance(q);
2379
2380 qPos.add(groupId);
2381
2382 if (articleId != null) {
2383 qPos.add(articleId);
2384 }
2385
2386 if (orderByComparator != null) {
2387 Object[] values = orderByComparator.getOrderByValues(journalArticle);
2388
2389 for (Object value : values) {
2390 qPos.add(value);
2391 }
2392 }
2393
2394 List<JournalArticle> list = q.list();
2395
2396 if (list.size() == 2) {
2397 return list.get(1);
2398 }
2399 else {
2400 return null;
2401 }
2402 }
2403
2404 public List<JournalArticle> findByG_S(long groupId, String structureId)
2405 throws SystemException {
2406 return findByG_S(groupId, structureId, QueryUtil.ALL_POS,
2407 QueryUtil.ALL_POS, null);
2408 }
2409
2410 public List<JournalArticle> findByG_S(long groupId, String structureId,
2411 int start, int end) throws SystemException {
2412 return findByG_S(groupId, structureId, start, end, null);
2413 }
2414
2415 public List<JournalArticle> findByG_S(long groupId, String structureId,
2416 int start, int end, OrderByComparator orderByComparator)
2417 throws SystemException {
2418 Object[] finderArgs = new Object[] {
2419 groupId, structureId,
2420
2421 String.valueOf(start), String.valueOf(end),
2422 String.valueOf(orderByComparator)
2423 };
2424
2425 List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_S,
2426 finderArgs, this);
2427
2428 if (list == null) {
2429 StringBundler query = null;
2430
2431 if (orderByComparator != null) {
2432 query = new StringBundler(4 +
2433 (orderByComparator.getOrderByFields().length * 3));
2434 }
2435 else {
2436 query = new StringBundler(4);
2437 }
2438
2439 query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
2440
2441 query.append(_FINDER_COLUMN_G_S_GROUPID_2);
2442
2443 if (structureId == null) {
2444 query.append(_FINDER_COLUMN_G_S_STRUCTUREID_1);
2445 }
2446 else {
2447 if (structureId.equals(StringPool.BLANK)) {
2448 query.append(_FINDER_COLUMN_G_S_STRUCTUREID_3);
2449 }
2450 else {
2451 query.append(_FINDER_COLUMN_G_S_STRUCTUREID_2);
2452 }
2453 }
2454
2455 if (orderByComparator != null) {
2456 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2457 orderByComparator);
2458 }
2459
2460 else {
2461 query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
2462 }
2463
2464 String sql = query.toString();
2465
2466 Session session = null;
2467
2468 try {
2469 session = openSession();
2470
2471 Query q = session.createQuery(sql);
2472
2473 QueryPos qPos = QueryPos.getInstance(q);
2474
2475 qPos.add(groupId);
2476
2477 if (structureId != null) {
2478 qPos.add(structureId);
2479 }
2480
2481 list = (List<JournalArticle>)QueryUtil.list(q, getDialect(),
2482 start, end);
2483 }
2484 catch (Exception e) {
2485 throw processException(e);
2486 }
2487 finally {
2488 if (list == null) {
2489 list = new ArrayList<JournalArticle>();
2490 }
2491
2492 cacheResult(list);
2493
2494 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_S, finderArgs,
2495 list);
2496
2497 closeSession(session);
2498 }
2499 }
2500
2501 return list;
2502 }
2503
2504 public JournalArticle findByG_S_First(long groupId, String structureId,
2505 OrderByComparator orderByComparator)
2506 throws NoSuchArticleException, SystemException {
2507 List<JournalArticle> list = findByG_S(groupId, structureId, 0, 1,
2508 orderByComparator);
2509
2510 if (list.isEmpty()) {
2511 StringBundler msg = new StringBundler(6);
2512
2513 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2514
2515 msg.append("groupId=");
2516 msg.append(groupId);
2517
2518 msg.append(", structureId=");
2519 msg.append(structureId);
2520
2521 msg.append(StringPool.CLOSE_CURLY_BRACE);
2522
2523 throw new NoSuchArticleException(msg.toString());
2524 }
2525 else {
2526 return list.get(0);
2527 }
2528 }
2529
2530 public JournalArticle findByG_S_Last(long groupId, String structureId,
2531 OrderByComparator orderByComparator)
2532 throws NoSuchArticleException, SystemException {
2533 int count = countByG_S(groupId, structureId);
2534
2535 List<JournalArticle> list = findByG_S(groupId, structureId, count - 1,
2536 count, orderByComparator);
2537
2538 if (list.isEmpty()) {
2539 StringBundler msg = new StringBundler(6);
2540
2541 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2542
2543 msg.append("groupId=");
2544 msg.append(groupId);
2545
2546 msg.append(", structureId=");
2547 msg.append(structureId);
2548
2549 msg.append(StringPool.CLOSE_CURLY_BRACE);
2550
2551 throw new NoSuchArticleException(msg.toString());
2552 }
2553 else {
2554 return list.get(0);
2555 }
2556 }
2557
2558 public JournalArticle[] findByG_S_PrevAndNext(long id, long groupId,
2559 String structureId, OrderByComparator orderByComparator)
2560 throws NoSuchArticleException, SystemException {
2561 JournalArticle journalArticle = findByPrimaryKey(id);
2562
2563 Session session = null;
2564
2565 try {
2566 session = openSession();
2567
2568 JournalArticle[] array = new JournalArticleImpl[3];
2569
2570 array[0] = getByG_S_PrevAndNext(session, journalArticle, groupId,
2571 structureId, orderByComparator, true);
2572
2573 array[1] = journalArticle;
2574
2575 array[2] = getByG_S_PrevAndNext(session, journalArticle, groupId,
2576 structureId, orderByComparator, false);
2577
2578 return array;
2579 }
2580 catch (Exception e) {
2581 throw processException(e);
2582 }
2583 finally {
2584 closeSession(session);
2585 }
2586 }
2587
2588 protected JournalArticle getByG_S_PrevAndNext(Session session,
2589 JournalArticle journalArticle, long groupId, String structureId,
2590 OrderByComparator orderByComparator, boolean previous) {
2591 StringBundler query = null;
2592
2593 if (orderByComparator != null) {
2594 query = new StringBundler(6 +
2595 (orderByComparator.getOrderByFields().length * 6));
2596 }
2597 else {
2598 query = new StringBundler(3);
2599 }
2600
2601 query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
2602
2603 query.append(_FINDER_COLUMN_G_S_GROUPID_2);
2604
2605 if (structureId == null) {
2606 query.append(_FINDER_COLUMN_G_S_STRUCTUREID_1);
2607 }
2608 else {
2609 if (structureId.equals(StringPool.BLANK)) {
2610 query.append(_FINDER_COLUMN_G_S_STRUCTUREID_3);
2611 }
2612 else {
2613 query.append(_FINDER_COLUMN_G_S_STRUCTUREID_2);
2614 }
2615 }
2616
2617 if (orderByComparator != null) {
2618 String[] orderByFields = orderByComparator.getOrderByFields();
2619
2620 if (orderByFields.length > 0) {
2621 query.append(WHERE_AND);
2622 }
2623
2624 for (int i = 0; i < orderByFields.length; i++) {
2625 query.append(_ORDER_BY_ENTITY_ALIAS);
2626 query.append(orderByFields[i]);
2627
2628 if ((i + 1) < orderByFields.length) {
2629 if (orderByComparator.isAscending() ^ previous) {
2630 query.append(WHERE_GREATER_THAN_HAS_NEXT);
2631 }
2632 else {
2633 query.append(WHERE_LESSER_THAN_HAS_NEXT);
2634 }
2635 }
2636 else {
2637 if (orderByComparator.isAscending() ^ previous) {
2638 query.append(WHERE_GREATER_THAN);
2639 }
2640 else {
2641 query.append(WHERE_LESSER_THAN);
2642 }
2643 }
2644 }
2645
2646 query.append(ORDER_BY_CLAUSE);
2647
2648 for (int i = 0; i < orderByFields.length; i++) {
2649 query.append(_ORDER_BY_ENTITY_ALIAS);
2650 query.append(orderByFields[i]);
2651
2652 if ((i + 1) < orderByFields.length) {
2653 if (orderByComparator.isAscending() ^ previous) {
2654 query.append(ORDER_BY_ASC_HAS_NEXT);
2655 }
2656 else {
2657 query.append(ORDER_BY_DESC_HAS_NEXT);
2658 }
2659 }
2660 else {
2661 if (orderByComparator.isAscending() ^ previous) {
2662 query.append(ORDER_BY_ASC);
2663 }
2664 else {
2665 query.append(ORDER_BY_DESC);
2666 }
2667 }
2668 }
2669 }
2670
2671 else {
2672 query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
2673 }
2674
2675 String sql = query.toString();
2676
2677 Query q = session.createQuery(sql);
2678
2679 q.setFirstResult(0);
2680 q.setMaxResults(2);
2681
2682 QueryPos qPos = QueryPos.getInstance(q);
2683
2684 qPos.add(groupId);
2685
2686 if (structureId != null) {
2687 qPos.add(structureId);
2688 }
2689
2690 if (orderByComparator != null) {
2691 Object[] values = orderByComparator.getOrderByValues(journalArticle);
2692
2693 for (Object value : values) {
2694 qPos.add(value);
2695 }
2696 }
2697
2698 List<JournalArticle> list = q.list();
2699
2700 if (list.size() == 2) {
2701 return list.get(1);
2702 }
2703 else {
2704 return null;
2705 }
2706 }
2707
2708 public List<JournalArticle> findByG_T(long groupId, String templateId)
2709 throws SystemException {
2710 return findByG_T(groupId, templateId, QueryUtil.ALL_POS,
2711 QueryUtil.ALL_POS, null);
2712 }
2713
2714 public List<JournalArticle> findByG_T(long groupId, String templateId,
2715 int start, int end) throws SystemException {
2716 return findByG_T(groupId, templateId, start, end, null);
2717 }
2718
2719 public List<JournalArticle> findByG_T(long groupId, String templateId,
2720 int start, int end, OrderByComparator orderByComparator)
2721 throws SystemException {
2722 Object[] finderArgs = new Object[] {
2723 groupId, templateId,
2724
2725 String.valueOf(start), String.valueOf(end),
2726 String.valueOf(orderByComparator)
2727 };
2728
2729 List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_T,
2730 finderArgs, this);
2731
2732 if (list == null) {
2733 StringBundler query = null;
2734
2735 if (orderByComparator != null) {
2736 query = new StringBundler(4 +
2737 (orderByComparator.getOrderByFields().length * 3));
2738 }
2739 else {
2740 query = new StringBundler(4);
2741 }
2742
2743 query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
2744
2745 query.append(_FINDER_COLUMN_G_T_GROUPID_2);
2746
2747 if (templateId == null) {
2748 query.append(_FINDER_COLUMN_G_T_TEMPLATEID_1);
2749 }
2750 else {
2751 if (templateId.equals(StringPool.BLANK)) {
2752 query.append(_FINDER_COLUMN_G_T_TEMPLATEID_3);
2753 }
2754 else {
2755 query.append(_FINDER_COLUMN_G_T_TEMPLATEID_2);
2756 }
2757 }
2758
2759 if (orderByComparator != null) {
2760 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2761 orderByComparator);
2762 }
2763
2764 else {
2765 query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
2766 }
2767
2768 String sql = query.toString();
2769
2770 Session session = null;
2771
2772 try {
2773 session = openSession();
2774
2775 Query q = session.createQuery(sql);
2776
2777 QueryPos qPos = QueryPos.getInstance(q);
2778
2779 qPos.add(groupId);
2780
2781 if (templateId != null) {
2782 qPos.add(templateId);
2783 }
2784
2785 list = (List<JournalArticle>)QueryUtil.list(q, getDialect(),
2786 start, end);
2787 }
2788 catch (Exception e) {
2789 throw processException(e);
2790 }
2791 finally {
2792 if (list == null) {
2793 list = new ArrayList<JournalArticle>();
2794 }
2795
2796 cacheResult(list);
2797
2798 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_T, finderArgs,
2799 list);
2800
2801 closeSession(session);
2802 }
2803 }
2804
2805 return list;
2806 }
2807
2808 public JournalArticle findByG_T_First(long groupId, String templateId,
2809 OrderByComparator orderByComparator)
2810 throws NoSuchArticleException, SystemException {
2811 List<JournalArticle> list = findByG_T(groupId, templateId, 0, 1,
2812 orderByComparator);
2813
2814 if (list.isEmpty()) {
2815 StringBundler msg = new StringBundler(6);
2816
2817 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2818
2819 msg.append("groupId=");
2820 msg.append(groupId);
2821
2822 msg.append(", templateId=");
2823 msg.append(templateId);
2824
2825 msg.append(StringPool.CLOSE_CURLY_BRACE);
2826
2827 throw new NoSuchArticleException(msg.toString());
2828 }
2829 else {
2830 return list.get(0);
2831 }
2832 }
2833
2834 public JournalArticle findByG_T_Last(long groupId, String templateId,
2835 OrderByComparator orderByComparator)
2836 throws NoSuchArticleException, SystemException {
2837 int count = countByG_T(groupId, templateId);
2838
2839 List<JournalArticle> list = findByG_T(groupId, templateId, count - 1,
2840 count, orderByComparator);
2841
2842 if (list.isEmpty()) {
2843 StringBundler msg = new StringBundler(6);
2844
2845 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2846
2847 msg.append("groupId=");
2848 msg.append(groupId);
2849
2850 msg.append(", templateId=");
2851 msg.append(templateId);
2852
2853 msg.append(StringPool.CLOSE_CURLY_BRACE);
2854
2855 throw new NoSuchArticleException(msg.toString());
2856 }
2857 else {
2858 return list.get(0);
2859 }
2860 }
2861
2862 public JournalArticle[] findByG_T_PrevAndNext(long id, long groupId,
2863 String templateId, OrderByComparator orderByComparator)
2864 throws NoSuchArticleException, SystemException {
2865 JournalArticle journalArticle = findByPrimaryKey(id);
2866
2867 Session session = null;
2868
2869 try {
2870 session = openSession();
2871
2872 JournalArticle[] array = new JournalArticleImpl[3];
2873
2874 array[0] = getByG_T_PrevAndNext(session, journalArticle, groupId,
2875 templateId, orderByComparator, true);
2876
2877 array[1] = journalArticle;
2878
2879 array[2] = getByG_T_PrevAndNext(session, journalArticle, groupId,
2880 templateId, orderByComparator, false);
2881
2882 return array;
2883 }
2884 catch (Exception e) {
2885 throw processException(e);
2886 }
2887 finally {
2888 closeSession(session);
2889 }
2890 }
2891
2892 protected JournalArticle getByG_T_PrevAndNext(Session session,
2893 JournalArticle journalArticle, long groupId, String templateId,
2894 OrderByComparator orderByComparator, boolean previous) {
2895 StringBundler query = null;
2896
2897 if (orderByComparator != null) {
2898 query = new StringBundler(6 +
2899 (orderByComparator.getOrderByFields().length * 6));
2900 }
2901 else {
2902 query = new StringBundler(3);
2903 }
2904
2905 query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
2906
2907 query.append(_FINDER_COLUMN_G_T_GROUPID_2);
2908
2909 if (templateId == null) {
2910 query.append(_FINDER_COLUMN_G_T_TEMPLATEID_1);
2911 }
2912 else {
2913 if (templateId.equals(StringPool.BLANK)) {
2914 query.append(_FINDER_COLUMN_G_T_TEMPLATEID_3);
2915 }
2916 else {
2917 query.append(_FINDER_COLUMN_G_T_TEMPLATEID_2);
2918 }
2919 }
2920
2921 if (orderByComparator != null) {
2922 String[] orderByFields = orderByComparator.getOrderByFields();
2923
2924 if (orderByFields.length > 0) {
2925 query.append(WHERE_AND);
2926 }
2927
2928 for (int i = 0; i < orderByFields.length; i++) {
2929 query.append(_ORDER_BY_ENTITY_ALIAS);
2930 query.append(orderByFields[i]);
2931
2932 if ((i + 1) < orderByFields.length) {
2933 if (orderByComparator.isAscending() ^ previous) {
2934 query.append(WHERE_GREATER_THAN_HAS_NEXT);
2935 }
2936 else {
2937 query.append(WHERE_LESSER_THAN_HAS_NEXT);
2938 }
2939 }
2940 else {
2941 if (orderByComparator.isAscending() ^ previous) {
2942 query.append(WHERE_GREATER_THAN);
2943 }
2944 else {
2945 query.append(WHERE_LESSER_THAN);
2946 }
2947 }
2948 }
2949
2950 query.append(ORDER_BY_CLAUSE);
2951
2952 for (int i = 0; i < orderByFields.length; i++) {
2953 query.append(_ORDER_BY_ENTITY_ALIAS);
2954 query.append(orderByFields[i]);
2955
2956 if ((i + 1) < orderByFields.length) {
2957 if (orderByComparator.isAscending() ^ previous) {
2958 query.append(ORDER_BY_ASC_HAS_NEXT);
2959 }
2960 else {
2961 query.append(ORDER_BY_DESC_HAS_NEXT);
2962 }
2963 }
2964 else {
2965 if (orderByComparator.isAscending() ^ previous) {
2966 query.append(ORDER_BY_ASC);
2967 }
2968 else {
2969 query.append(ORDER_BY_DESC);
2970 }
2971 }
2972 }
2973 }
2974
2975 else {
2976 query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
2977 }
2978
2979 String sql = query.toString();
2980
2981 Query q = session.createQuery(sql);
2982
2983 q.setFirstResult(0);
2984 q.setMaxResults(2);
2985
2986 QueryPos qPos = QueryPos.getInstance(q);
2987
2988 qPos.add(groupId);
2989
2990 if (templateId != null) {
2991 qPos.add(templateId);
2992 }
2993
2994 if (orderByComparator != null) {
2995 Object[] values = orderByComparator.getOrderByValues(journalArticle);
2996
2997 for (Object value : values) {
2998 qPos.add(value);
2999 }
3000 }
3001
3002 List<JournalArticle> list = q.list();
3003
3004 if (list.size() == 2) {
3005 return list.get(1);
3006 }
3007 else {
3008 return null;
3009 }
3010 }
3011
3012 public List<JournalArticle> findByG_UT(long groupId, String urlTitle)
3013 throws SystemException {
3014 return findByG_UT(groupId, urlTitle, QueryUtil.ALL_POS,
3015 QueryUtil.ALL_POS, null);
3016 }
3017
3018 public List<JournalArticle> findByG_UT(long groupId, String urlTitle,
3019 int start, int end) throws SystemException {
3020 return findByG_UT(groupId, urlTitle, start, end, null);
3021 }
3022
3023 public List<JournalArticle> findByG_UT(long groupId, String urlTitle,
3024 int start, int end, OrderByComparator orderByComparator)
3025 throws SystemException {
3026 Object[] finderArgs = new Object[] {
3027 groupId, urlTitle,
3028
3029 String.valueOf(start), String.valueOf(end),
3030 String.valueOf(orderByComparator)
3031 };
3032
3033 List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_UT,
3034 finderArgs, this);
3035
3036 if (list == null) {
3037 StringBundler query = null;
3038
3039 if (orderByComparator != null) {
3040 query = new StringBundler(4 +
3041 (orderByComparator.getOrderByFields().length * 3));
3042 }
3043 else {
3044 query = new StringBundler(4);
3045 }
3046
3047 query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
3048
3049 query.append(_FINDER_COLUMN_G_UT_GROUPID_2);
3050
3051 if (urlTitle == null) {
3052 query.append(_FINDER_COLUMN_G_UT_URLTITLE_1);
3053 }
3054 else {
3055 if (urlTitle.equals(StringPool.BLANK)) {
3056 query.append(_FINDER_COLUMN_G_UT_URLTITLE_3);
3057 }
3058 else {
3059 query.append(_FINDER_COLUMN_G_UT_URLTITLE_2);
3060 }
3061 }
3062
3063 if (orderByComparator != null) {
3064 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
3065 orderByComparator);
3066 }
3067
3068 else {
3069 query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
3070 }
3071
3072 String sql = query.toString();
3073
3074 Session session = null;
3075
3076 try {
3077 session = openSession();
3078
3079 Query q = session.createQuery(sql);
3080
3081 QueryPos qPos = QueryPos.getInstance(q);
3082
3083 qPos.add(groupId);
3084
3085 if (urlTitle != null) {
3086 qPos.add(urlTitle);
3087 }
3088
3089 list = (List<JournalArticle>)QueryUtil.list(q, getDialect(),
3090 start, end);
3091 }
3092 catch (Exception e) {
3093 throw processException(e);
3094 }
3095 finally {
3096 if (list == null) {
3097 list = new ArrayList<JournalArticle>();
3098 }
3099
3100 cacheResult(list);
3101
3102 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_UT, finderArgs,
3103 list);
3104
3105 closeSession(session);
3106 }
3107 }
3108
3109 return list;
3110 }
3111
3112 public JournalArticle findByG_UT_First(long groupId, String urlTitle,
3113 OrderByComparator orderByComparator)
3114 throws NoSuchArticleException, SystemException {
3115 List<JournalArticle> list = findByG_UT(groupId, urlTitle, 0, 1,
3116 orderByComparator);
3117
3118 if (list.isEmpty()) {
3119 StringBundler msg = new StringBundler(6);
3120
3121 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3122
3123 msg.append("groupId=");
3124 msg.append(groupId);
3125
3126 msg.append(", urlTitle=");
3127 msg.append(urlTitle);
3128
3129 msg.append(StringPool.CLOSE_CURLY_BRACE);
3130
3131 throw new NoSuchArticleException(msg.toString());
3132 }
3133 else {
3134 return list.get(0);
3135 }
3136 }
3137
3138 public JournalArticle findByG_UT_Last(long groupId, String urlTitle,
3139 OrderByComparator orderByComparator)
3140 throws NoSuchArticleException, SystemException {
3141 int count = countByG_UT(groupId, urlTitle);
3142
3143 List<JournalArticle> list = findByG_UT(groupId, urlTitle, count - 1,
3144 count, orderByComparator);
3145
3146 if (list.isEmpty()) {
3147 StringBundler msg = new StringBundler(6);
3148
3149 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3150
3151 msg.append("groupId=");
3152 msg.append(groupId);
3153
3154 msg.append(", urlTitle=");
3155 msg.append(urlTitle);
3156
3157 msg.append(StringPool.CLOSE_CURLY_BRACE);
3158
3159 throw new NoSuchArticleException(msg.toString());
3160 }
3161 else {
3162 return list.get(0);
3163 }
3164 }
3165
3166 public JournalArticle[] findByG_UT_PrevAndNext(long id, long groupId,
3167 String urlTitle, OrderByComparator orderByComparator)
3168 throws NoSuchArticleException, SystemException {
3169 JournalArticle journalArticle = findByPrimaryKey(id);
3170
3171 Session session = null;
3172
3173 try {
3174 session = openSession();
3175
3176 JournalArticle[] array = new JournalArticleImpl[3];
3177
3178 array[0] = getByG_UT_PrevAndNext(session, journalArticle, groupId,
3179 urlTitle, orderByComparator, true);
3180
3181 array[1] = journalArticle;
3182
3183 array[2] = getByG_UT_PrevAndNext(session, journalArticle, groupId,
3184 urlTitle, orderByComparator, false);
3185
3186 return array;
3187 }
3188 catch (Exception e) {
3189 throw processException(e);
3190 }
3191 finally {
3192 closeSession(session);
3193 }
3194 }
3195
3196 protected JournalArticle getByG_UT_PrevAndNext(Session session,
3197 JournalArticle journalArticle, long groupId, String urlTitle,
3198 OrderByComparator orderByComparator, boolean previous) {
3199 StringBundler query = null;
3200
3201 if (orderByComparator != null) {
3202 query = new StringBundler(6 +
3203 (orderByComparator.getOrderByFields().length * 6));
3204 }
3205 else {
3206 query = new StringBundler(3);
3207 }
3208
3209 query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
3210
3211 query.append(_FINDER_COLUMN_G_UT_GROUPID_2);
3212
3213 if (urlTitle == null) {
3214 query.append(_FINDER_COLUMN_G_UT_URLTITLE_1);
3215 }
3216 else {
3217 if (urlTitle.equals(StringPool.BLANK)) {
3218 query.append(_FINDER_COLUMN_G_UT_URLTITLE_3);
3219 }
3220 else {
3221 query.append(_FINDER_COLUMN_G_UT_URLTITLE_2);
3222 }
3223 }
3224
3225 if (orderByComparator != null) {
3226 String[] orderByFields = orderByComparator.getOrderByFields();
3227
3228 if (orderByFields.length > 0) {
3229 query.append(WHERE_AND);
3230 }
3231
3232 for (int i = 0; i < orderByFields.length; i++) {
3233 query.append(_ORDER_BY_ENTITY_ALIAS);
3234 query.append(orderByFields[i]);
3235
3236 if ((i + 1) < orderByFields.length) {
3237 if (orderByComparator.isAscending() ^ previous) {
3238 query.append(WHERE_GREATER_THAN_HAS_NEXT);
3239 }
3240 else {
3241 query.append(WHERE_LESSER_THAN_HAS_NEXT);
3242 }
3243 }
3244 else {
3245 if (orderByComparator.isAscending() ^ previous) {
3246 query.append(WHERE_GREATER_THAN);
3247 }
3248 else {
3249 query.append(WHERE_LESSER_THAN);
3250 }
3251 }
3252 }
3253
3254 query.append(ORDER_BY_CLAUSE);
3255
3256 for (int i = 0; i < orderByFields.length; i++) {
3257 query.append(_ORDER_BY_ENTITY_ALIAS);
3258 query.append(orderByFields[i]);
3259
3260 if ((i + 1) < orderByFields.length) {
3261 if (orderByComparator.isAscending() ^ previous) {
3262 query.append(ORDER_BY_ASC_HAS_NEXT);
3263 }
3264 else {
3265 query.append(ORDER_BY_DESC_HAS_NEXT);
3266 }
3267 }
3268 else {
3269 if (orderByComparator.isAscending() ^ previous) {
3270 query.append(ORDER_BY_ASC);
3271 }
3272 else {
3273 query.append(ORDER_BY_DESC);
3274 }
3275 }
3276 }
3277 }
3278
3279 else {
3280 query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
3281 }
3282
3283 String sql = query.toString();
3284
3285 Query q = session.createQuery(sql);
3286
3287 q.setFirstResult(0);
3288 q.setMaxResults(2);
3289
3290 QueryPos qPos = QueryPos.getInstance(q);
3291
3292 qPos.add(groupId);
3293
3294 if (urlTitle != null) {
3295 qPos.add(urlTitle);
3296 }
3297
3298 if (orderByComparator != null) {
3299 Object[] values = orderByComparator.getOrderByValues(journalArticle);
3300
3301 for (Object value : values) {
3302 qPos.add(value);
3303 }
3304 }
3305
3306 List<JournalArticle> list = q.list();
3307
3308 if (list.size() == 2) {
3309 return list.get(1);
3310 }
3311 else {
3312 return null;
3313 }
3314 }
3315
3316 public JournalArticle findByG_A_V(long groupId, String articleId,
3317 double version) throws NoSuchArticleException, SystemException {
3318 JournalArticle journalArticle = fetchByG_A_V(groupId, articleId, version);
3319
3320 if (journalArticle == null) {
3321 StringBundler msg = new StringBundler(8);
3322
3323 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3324
3325 msg.append("groupId=");
3326 msg.append(groupId);
3327
3328 msg.append(", articleId=");
3329 msg.append(articleId);
3330
3331 msg.append(", version=");
3332 msg.append(version);
3333
3334 msg.append(StringPool.CLOSE_CURLY_BRACE);
3335
3336 if (_log.isWarnEnabled()) {
3337 _log.warn(msg.toString());
3338 }
3339
3340 throw new NoSuchArticleException(msg.toString());
3341 }
3342
3343 return journalArticle;
3344 }
3345
3346 public JournalArticle fetchByG_A_V(long groupId, String articleId,
3347 double version) throws SystemException {
3348 return fetchByG_A_V(groupId, articleId, version, true);
3349 }
3350
3351 public JournalArticle fetchByG_A_V(long groupId, String articleId,
3352 double version, boolean retrieveFromCache) throws SystemException {
3353 Object[] finderArgs = new Object[] { groupId, articleId, version };
3354
3355 Object result = null;
3356
3357 if (retrieveFromCache) {
3358 result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_G_A_V,
3359 finderArgs, this);
3360 }
3361
3362 if (result == null) {
3363 StringBundler query = new StringBundler(5);
3364
3365 query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
3366
3367 query.append(_FINDER_COLUMN_G_A_V_GROUPID_2);
3368
3369 if (articleId == null) {
3370 query.append(_FINDER_COLUMN_G_A_V_ARTICLEID_1);
3371 }
3372 else {
3373 if (articleId.equals(StringPool.BLANK)) {
3374 query.append(_FINDER_COLUMN_G_A_V_ARTICLEID_3);
3375 }
3376 else {
3377 query.append(_FINDER_COLUMN_G_A_V_ARTICLEID_2);
3378 }
3379 }
3380
3381 query.append(_FINDER_COLUMN_G_A_V_VERSION_2);
3382
3383 query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
3384
3385 String sql = query.toString();
3386
3387 Session session = null;
3388
3389 try {
3390 session = openSession();
3391
3392 Query q = session.createQuery(sql);
3393
3394 QueryPos qPos = QueryPos.getInstance(q);
3395
3396 qPos.add(groupId);
3397
3398 if (articleId != null) {
3399 qPos.add(articleId);
3400 }
3401
3402 qPos.add(version);
3403
3404 List<JournalArticle> list = q.list();
3405
3406 result = list;
3407
3408 JournalArticle journalArticle = null;
3409
3410 if (list.isEmpty()) {
3411 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A_V,
3412 finderArgs, list);
3413 }
3414 else {
3415 journalArticle = list.get(0);
3416
3417 cacheResult(journalArticle);
3418
3419 if ((journalArticle.getGroupId() != groupId) ||
3420 (journalArticle.getArticleId() == null) ||
3421 !journalArticle.getArticleId().equals(articleId) ||
3422 (journalArticle.getVersion() != version)) {
3423 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A_V,
3424 finderArgs, journalArticle);
3425 }
3426 }
3427
3428 return journalArticle;
3429 }
3430 catch (Exception e) {
3431 throw processException(e);
3432 }
3433 finally {
3434 if (result == null) {
3435 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A_V,
3436 finderArgs, new ArrayList<JournalArticle>());
3437 }
3438
3439 closeSession(session);
3440 }
3441 }
3442 else {
3443 if (result instanceof List<?>) {
3444 return null;
3445 }
3446 else {
3447 return (JournalArticle)result;
3448 }
3449 }
3450 }
3451
3452 public List<JournalArticle> findByG_A_A(long groupId, String articleId,
3453 boolean approved) throws SystemException {
3454 return findByG_A_A(groupId, articleId, approved, QueryUtil.ALL_POS,
3455 QueryUtil.ALL_POS, null);
3456 }
3457
3458 public List<JournalArticle> findByG_A_A(long groupId, String articleId,
3459 boolean approved, int start, int end) throws SystemException {
3460 return findByG_A_A(groupId, articleId, approved, start, end, null);
3461 }
3462
3463 public List<JournalArticle> findByG_A_A(long groupId, String articleId,
3464 boolean approved, int start, int end,
3465 OrderByComparator orderByComparator) throws SystemException {
3466 Object[] finderArgs = new Object[] {
3467 groupId, articleId, approved,
3468
3469 String.valueOf(start), String.valueOf(end),
3470 String.valueOf(orderByComparator)
3471 };
3472
3473 List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_A_A,
3474 finderArgs, this);
3475
3476 if (list == null) {
3477 StringBundler query = null;
3478
3479 if (orderByComparator != null) {
3480 query = new StringBundler(5 +
3481 (orderByComparator.getOrderByFields().length * 3));
3482 }
3483 else {
3484 query = new StringBundler(5);
3485 }
3486
3487 query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
3488
3489 query.append(_FINDER_COLUMN_G_A_A_GROUPID_2);
3490
3491 if (articleId == null) {
3492 query.append(_FINDER_COLUMN_G_A_A_ARTICLEID_1);
3493 }
3494 else {
3495 if (articleId.equals(StringPool.BLANK)) {
3496 query.append(_FINDER_COLUMN_G_A_A_ARTICLEID_3);
3497 }
3498 else {
3499 query.append(_FINDER_COLUMN_G_A_A_ARTICLEID_2);
3500 }
3501 }
3502
3503 query.append(_FINDER_COLUMN_G_A_A_APPROVED_2);
3504
3505 if (orderByComparator != null) {
3506 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
3507 orderByComparator);
3508 }
3509
3510 else {
3511 query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
3512 }
3513
3514 String sql = query.toString();
3515
3516 Session session = null;
3517
3518 try {
3519 session = openSession();
3520
3521 Query q = session.createQuery(sql);
3522
3523 QueryPos qPos = QueryPos.getInstance(q);
3524
3525 qPos.add(groupId);
3526
3527 if (articleId != null) {
3528 qPos.add(articleId);
3529 }
3530
3531 qPos.add(approved);
3532
3533 list = (List<JournalArticle>)QueryUtil.list(q, getDialect(),
3534 start, end);
3535 }
3536 catch (Exception e) {
3537 throw processException(e);
3538 }
3539 finally {
3540 if (list == null) {
3541 list = new ArrayList<JournalArticle>();
3542 }
3543
3544 cacheResult(list);
3545
3546 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_A_A,
3547 finderArgs, list);
3548
3549 closeSession(session);
3550 }
3551 }
3552
3553 return list;
3554 }
3555
3556 public JournalArticle findByG_A_A_First(long groupId, String articleId,
3557 boolean approved, OrderByComparator orderByComparator)
3558 throws NoSuchArticleException, SystemException {
3559 List<JournalArticle> list = findByG_A_A(groupId, articleId, approved,
3560 0, 1, orderByComparator);
3561
3562 if (list.isEmpty()) {
3563 StringBundler msg = new StringBundler(8);
3564
3565 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3566
3567 msg.append("groupId=");
3568 msg.append(groupId);
3569
3570 msg.append(", articleId=");
3571 msg.append(articleId);
3572
3573 msg.append(", approved=");
3574 msg.append(approved);
3575
3576 msg.append(StringPool.CLOSE_CURLY_BRACE);
3577
3578 throw new NoSuchArticleException(msg.toString());
3579 }
3580 else {
3581 return list.get(0);
3582 }
3583 }
3584
3585 public JournalArticle findByG_A_A_Last(long groupId, String articleId,
3586 boolean approved, OrderByComparator orderByComparator)
3587 throws NoSuchArticleException, SystemException {
3588 int count = countByG_A_A(groupId, articleId, approved);
3589
3590 List<JournalArticle> list = findByG_A_A(groupId, articleId, approved,
3591 count - 1, count, orderByComparator);
3592
3593 if (list.isEmpty()) {
3594 StringBundler msg = new StringBundler(8);
3595
3596 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3597
3598 msg.append("groupId=");
3599 msg.append(groupId);
3600
3601 msg.append(", articleId=");
3602 msg.append(articleId);
3603
3604 msg.append(", approved=");
3605 msg.append(approved);
3606
3607 msg.append(StringPool.CLOSE_CURLY_BRACE);
3608
3609 throw new NoSuchArticleException(msg.toString());
3610 }
3611 else {
3612 return list.get(0);
3613 }
3614 }
3615
3616 public JournalArticle[] findByG_A_A_PrevAndNext(long id, long groupId,
3617 String articleId, boolean approved, OrderByComparator orderByComparator)
3618 throws NoSuchArticleException, SystemException {
3619 JournalArticle journalArticle = findByPrimaryKey(id);
3620
3621 Session session = null;
3622
3623 try {
3624 session = openSession();
3625
3626 JournalArticle[] array = new JournalArticleImpl[3];
3627
3628 array[0] = getByG_A_A_PrevAndNext(session, journalArticle, groupId,
3629 articleId, approved, orderByComparator, true);
3630
3631 array[1] = journalArticle;
3632
3633 array[2] = getByG_A_A_PrevAndNext(session, journalArticle, groupId,
3634 articleId, approved, orderByComparator, false);
3635
3636 return array;
3637 }
3638 catch (Exception e) {
3639 throw processException(e);
3640 }
3641 finally {
3642 closeSession(session);
3643 }
3644 }
3645
3646 protected JournalArticle getByG_A_A_PrevAndNext(Session session,
3647 JournalArticle journalArticle, long groupId, String articleId,
3648 boolean approved, OrderByComparator orderByComparator, boolean previous) {
3649 StringBundler query = null;
3650
3651 if (orderByComparator != null) {
3652 query = new StringBundler(6 +
3653 (orderByComparator.getOrderByFields().length * 6));
3654 }
3655 else {
3656 query = new StringBundler(3);
3657 }
3658
3659 query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
3660
3661 query.append(_FINDER_COLUMN_G_A_A_GROUPID_2);
3662
3663 if (articleId == null) {
3664 query.append(_FINDER_COLUMN_G_A_A_ARTICLEID_1);
3665 }
3666 else {
3667 if (articleId.equals(StringPool.BLANK)) {
3668 query.append(_FINDER_COLUMN_G_A_A_ARTICLEID_3);
3669 }
3670 else {
3671 query.append(_FINDER_COLUMN_G_A_A_ARTICLEID_2);
3672 }
3673 }
3674
3675 query.append(_FINDER_COLUMN_G_A_A_APPROVED_2);
3676
3677 if (orderByComparator != null) {
3678 String[] orderByFields = orderByComparator.getOrderByFields();
3679
3680 if (orderByFields.length > 0) {
3681 query.append(WHERE_AND);
3682 }
3683
3684 for (int i = 0; i < orderByFields.length; i++) {
3685 query.append(_ORDER_BY_ENTITY_ALIAS);
3686 query.append(orderByFields[i]);
3687
3688 if ((i + 1) < orderByFields.length) {
3689 if (orderByComparator.isAscending() ^ previous) {
3690 query.append(WHERE_GREATER_THAN_HAS_NEXT);
3691 }
3692 else {
3693 query.append(WHERE_LESSER_THAN_HAS_NEXT);
3694 }
3695 }
3696 else {
3697 if (orderByComparator.isAscending() ^ previous) {
3698 query.append(WHERE_GREATER_THAN);
3699 }
3700 else {
3701 query.append(WHERE_LESSER_THAN);
3702 }
3703 }
3704 }
3705
3706 query.append(ORDER_BY_CLAUSE);
3707
3708 for (int i = 0; i < orderByFields.length; i++) {
3709 query.append(_ORDER_BY_ENTITY_ALIAS);
3710 query.append(orderByFields[i]);
3711
3712 if ((i + 1) < orderByFields.length) {
3713 if (orderByComparator.isAscending() ^ previous) {
3714 query.append(ORDER_BY_ASC_HAS_NEXT);
3715 }
3716 else {
3717 query.append(ORDER_BY_DESC_HAS_NEXT);
3718 }
3719 }
3720 else {
3721 if (orderByComparator.isAscending() ^ previous) {
3722 query.append(ORDER_BY_ASC);
3723 }
3724 else {
3725 query.append(ORDER_BY_DESC);
3726 }
3727 }
3728 }
3729 }
3730
3731 else {
3732 query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
3733 }
3734
3735 String sql = query.toString();
3736
3737 Query q = session.createQuery(sql);
3738
3739 q.setFirstResult(0);
3740 q.setMaxResults(2);
3741
3742 QueryPos qPos = QueryPos.getInstance(q);
3743
3744 qPos.add(groupId);
3745
3746 if (articleId != null) {
3747 qPos.add(articleId);
3748 }
3749
3750 qPos.add(approved);
3751
3752 if (orderByComparator != null) {
3753 Object[] values = orderByComparator.getOrderByValues(journalArticle);
3754
3755 for (Object value : values) {
3756 qPos.add(value);
3757 }
3758 }
3759
3760 List<JournalArticle> list = q.list();
3761
3762 if (list.size() == 2) {
3763 return list.get(1);
3764 }
3765 else {
3766 return null;
3767 }
3768 }
3769
3770 public List<JournalArticle> findByG_UT_A(long groupId, String urlTitle,
3771 boolean approved) throws SystemException {
3772 return findByG_UT_A(groupId, urlTitle, approved, QueryUtil.ALL_POS,
3773 QueryUtil.ALL_POS, null);
3774 }
3775
3776 public List<JournalArticle> findByG_UT_A(long groupId, String urlTitle,
3777 boolean approved, int start, int end) throws SystemException {
3778 return findByG_UT_A(groupId, urlTitle, approved, start, end, null);
3779 }
3780
3781 public List<JournalArticle> findByG_UT_A(long groupId, String urlTitle,
3782 boolean approved, int start, int end,
3783 OrderByComparator orderByComparator) throws SystemException {
3784 Object[] finderArgs = new Object[] {
3785 groupId, urlTitle, approved,
3786
3787 String.valueOf(start), String.valueOf(end),
3788 String.valueOf(orderByComparator)
3789 };
3790
3791 List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_UT_A,
3792 finderArgs, this);
3793
3794 if (list == null) {
3795 StringBundler query = null;
3796
3797 if (orderByComparator != null) {
3798 query = new StringBundler(5 +
3799 (orderByComparator.getOrderByFields().length * 3));
3800 }
3801 else {
3802 query = new StringBundler(5);
3803 }
3804
3805 query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
3806
3807 query.append(_FINDER_COLUMN_G_UT_A_GROUPID_2);
3808
3809 if (urlTitle == null) {
3810 query.append(_FINDER_COLUMN_G_UT_A_URLTITLE_1);
3811 }
3812 else {
3813 if (urlTitle.equals(StringPool.BLANK)) {
3814 query.append(_FINDER_COLUMN_G_UT_A_URLTITLE_3);
3815 }
3816 else {
3817 query.append(_FINDER_COLUMN_G_UT_A_URLTITLE_2);
3818 }
3819 }
3820
3821 query.append(_FINDER_COLUMN_G_UT_A_APPROVED_2);
3822
3823 if (orderByComparator != null) {
3824 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
3825 orderByComparator);
3826 }
3827
3828 else {
3829 query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
3830 }
3831
3832 String sql = query.toString();
3833
3834 Session session = null;
3835
3836 try {
3837 session = openSession();
3838
3839 Query q = session.createQuery(sql);
3840
3841 QueryPos qPos = QueryPos.getInstance(q);
3842
3843 qPos.add(groupId);
3844
3845 if (urlTitle != null) {
3846 qPos.add(urlTitle);
3847 }
3848
3849 qPos.add(approved);
3850
3851 list = (List<JournalArticle>)QueryUtil.list(q, getDialect(),
3852 start, end);
3853 }
3854 catch (Exception e) {
3855 throw processException(e);
3856 }
3857 finally {
3858 if (list == null) {
3859 list = new ArrayList<JournalArticle>();
3860 }
3861
3862 cacheResult(list);
3863
3864 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_UT_A,
3865 finderArgs, list);
3866
3867 closeSession(session);
3868 }
3869 }
3870
3871 return list;
3872 }
3873
3874 public JournalArticle findByG_UT_A_First(long groupId, String urlTitle,
3875 boolean approved, OrderByComparator orderByComparator)
3876 throws NoSuchArticleException, SystemException {
3877 List<JournalArticle> list = findByG_UT_A(groupId, urlTitle, approved,
3878 0, 1, orderByComparator);
3879
3880 if (list.isEmpty()) {
3881 StringBundler msg = new StringBundler(8);
3882
3883 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3884
3885 msg.append("groupId=");
3886 msg.append(groupId);
3887
3888 msg.append(", urlTitle=");
3889 msg.append(urlTitle);
3890
3891 msg.append(", approved=");
3892 msg.append(approved);
3893
3894 msg.append(StringPool.CLOSE_CURLY_BRACE);
3895
3896 throw new NoSuchArticleException(msg.toString());
3897 }
3898 else {
3899 return list.get(0);
3900 }
3901 }
3902
3903 public JournalArticle findByG_UT_A_Last(long groupId, String urlTitle,
3904 boolean approved, OrderByComparator orderByComparator)
3905 throws NoSuchArticleException, SystemException {
3906 int count = countByG_UT_A(groupId, urlTitle, approved);
3907
3908 List<JournalArticle> list = findByG_UT_A(groupId, urlTitle, approved,
3909 count - 1, count, orderByComparator);
3910
3911 if (list.isEmpty()) {
3912 StringBundler msg = new StringBundler(8);
3913
3914 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3915
3916 msg.append("groupId=");
3917 msg.append(groupId);
3918
3919 msg.append(", urlTitle=");
3920 msg.append(urlTitle);
3921
3922 msg.append(", approved=");
3923 msg.append(approved);
3924
3925 msg.append(StringPool.CLOSE_CURLY_BRACE);
3926
3927 throw new NoSuchArticleException(msg.toString());
3928 }
3929 else {
3930 return list.get(0);
3931 }
3932 }
3933
3934 public JournalArticle[] findByG_UT_A_PrevAndNext(long id, long groupId,
3935 String urlTitle, boolean approved, OrderByComparator orderByComparator)
3936 throws NoSuchArticleException, SystemException {
3937 JournalArticle journalArticle = findByPrimaryKey(id);
3938
3939 Session session = null;
3940
3941 try {
3942 session = openSession();
3943
3944 JournalArticle[] array = new JournalArticleImpl[3];
3945
3946 array[0] = getByG_UT_A_PrevAndNext(session, journalArticle,
3947 groupId, urlTitle, approved, orderByComparator, true);
3948
3949 array[1] = journalArticle;
3950
3951 array[2] = getByG_UT_A_PrevAndNext(session, journalArticle,
3952 groupId, urlTitle, approved, orderByComparator, false);
3953
3954 return array;
3955 }
3956 catch (Exception e) {
3957 throw processException(e);
3958 }
3959 finally {
3960 closeSession(session);
3961 }
3962 }
3963
3964 protected JournalArticle getByG_UT_A_PrevAndNext(Session session,
3965 JournalArticle journalArticle, long groupId, String urlTitle,
3966 boolean approved, OrderByComparator orderByComparator, boolean previous) {
3967 StringBundler query = null;
3968
3969 if (orderByComparator != null) {
3970 query = new StringBundler(6 +
3971 (orderByComparator.getOrderByFields().length * 6));
3972 }
3973 else {
3974 query = new StringBundler(3);
3975 }
3976
3977 query.append(_SQL_SELECT_JOURNALARTICLE_WHERE);
3978
3979 query.append(_FINDER_COLUMN_G_UT_A_GROUPID_2);
3980
3981 if (urlTitle == null) {
3982 query.append(_FINDER_COLUMN_G_UT_A_URLTITLE_1);
3983 }
3984 else {
3985 if (urlTitle.equals(StringPool.BLANK)) {
3986 query.append(_FINDER_COLUMN_G_UT_A_URLTITLE_3);
3987 }
3988 else {
3989 query.append(_FINDER_COLUMN_G_UT_A_URLTITLE_2);
3990 }
3991 }
3992
3993 query.append(_FINDER_COLUMN_G_UT_A_APPROVED_2);
3994
3995 if (orderByComparator != null) {
3996 String[] orderByFields = orderByComparator.getOrderByFields();
3997
3998 if (orderByFields.length > 0) {
3999 query.append(WHERE_AND);
4000 }
4001
4002 for (int i = 0; i < orderByFields.length; i++) {
4003 query.append(_ORDER_BY_ENTITY_ALIAS);
4004 query.append(orderByFields[i]);
4005
4006 if ((i + 1) < orderByFields.length) {
4007 if (orderByComparator.isAscending() ^ previous) {
4008 query.append(WHERE_GREATER_THAN_HAS_NEXT);
4009 }
4010 else {
4011 query.append(WHERE_LESSER_THAN_HAS_NEXT);
4012 }
4013 }
4014 else {
4015 if (orderByComparator.isAscending() ^ previous) {
4016 query.append(WHERE_GREATER_THAN);
4017 }
4018 else {
4019 query.append(WHERE_LESSER_THAN);
4020 }
4021 }
4022 }
4023
4024 query.append(ORDER_BY_CLAUSE);
4025
4026 for (int i = 0; i < orderByFields.length; i++) {
4027 query.append(_ORDER_BY_ENTITY_ALIAS);
4028 query.append(orderByFields[i]);
4029
4030 if ((i + 1) < orderByFields.length) {
4031 if (orderByComparator.isAscending() ^ previous) {
4032 query.append(ORDER_BY_ASC_HAS_NEXT);
4033 }
4034 else {
4035 query.append(ORDER_BY_DESC_HAS_NEXT);
4036 }
4037 }
4038 else {
4039 if (orderByComparator.isAscending() ^ previous) {
4040 query.append(ORDER_BY_ASC);
4041 }
4042 else {
4043 query.append(ORDER_BY_DESC);
4044 }
4045 }
4046 }
4047 }
4048
4049 else {
4050 query.append(JournalArticleModelImpl.ORDER_BY_JPQL);
4051 }
4052
4053 String sql = query.toString();
4054
4055 Query q = session.createQuery(sql);
4056
4057 q.setFirstResult(0);
4058 q.setMaxResults(2);
4059
4060 QueryPos qPos = QueryPos.getInstance(q);
4061
4062 qPos.add(groupId);
4063
4064 if (urlTitle != null) {
4065 qPos.add(urlTitle);
4066 }
4067
4068 qPos.add(approved);
4069
4070 if (orderByComparator != null) {
4071 Object[] values = orderByComparator.getOrderByValues(journalArticle);
4072
4073 for (Object value : values) {
4074 qPos.add(value);
4075 }
4076 }
4077
4078 List<JournalArticle> list = q.list();
4079
4080 if (list.size() == 2) {
4081 return list.get(1);
4082 }
4083 else {
4084 return null;
4085 }
4086 }
4087
4088 public List<JournalArticle> findAll() throws SystemException {
4089 return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
4090 }
4091
4092 public List<JournalArticle> findAll(int start, int end)
4093 throws SystemException {
4094 return findAll(start, end, null);
4095 }
4096
4097 public List<JournalArticle> findAll(int start, int end,
4098 OrderByComparator orderByComparator) throws SystemException {
4099 Object[] finderArgs = new Object[] {
4100 String.valueOf(start), String.valueOf(end),
4101 String.valueOf(orderByComparator)
4102 };
4103
4104 List<JournalArticle> list = (List<JournalArticle>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
4105 finderArgs, this);
4106
4107 if (list == null) {
4108 StringBundler query = null;
4109 String sql = null;
4110
4111 if (orderByComparator != null) {
4112 query = new StringBundler(2 +
4113 (orderByComparator.getOrderByFields().length * 3));
4114
4115 query.append(_SQL_SELECT_JOURNALARTICLE);
4116
4117 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
4118 orderByComparator);
4119
4120 sql = query.toString();
4121 }
4122 else {
4123 sql = _SQL_SELECT_JOURNALARTICLE.concat(JournalArticleModelImpl.ORDER_BY_JPQL);
4124 }
4125
4126 Session session = null;
4127
4128 try {
4129 session = openSession();
4130
4131 Query q = session.createQuery(sql);
4132
4133 if (orderByComparator == null) {
4134 list = (List<JournalArticle>)QueryUtil.list(q,
4135 getDialect(), start, end, false);
4136
4137 Collections.sort(list);
4138 }
4139 else {
4140 list = (List<JournalArticle>)QueryUtil.list(q,
4141 getDialect(), start, end);
4142 }
4143 }
4144 catch (Exception e) {
4145 throw processException(e);
4146 }
4147 finally {
4148 if (list == null) {
4149 list = new ArrayList<JournalArticle>();
4150 }
4151
4152 cacheResult(list);
4153
4154 FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
4155
4156 closeSession(session);
4157 }
4158 }
4159
4160 return list;
4161 }
4162
4163 public void removeByUuid(String uuid) throws SystemException {
4164 for (JournalArticle journalArticle : findByUuid(uuid)) {
4165 remove(journalArticle);
4166 }
4167 }
4168
4169 public void removeByUUID_G(String uuid, long groupId)
4170 throws NoSuchArticleException, SystemException {
4171 JournalArticle journalArticle = findByUUID_G(uuid, groupId);
4172
4173 remove(journalArticle);
4174 }
4175
4176 public void removeByGroupId(long groupId) throws SystemException {
4177 for (JournalArticle journalArticle : findByGroupId(groupId)) {
4178 remove(journalArticle);
4179 }
4180 }
4181
4182 public void removeByCompanyId(long companyId) throws SystemException {
4183 for (JournalArticle journalArticle : findByCompanyId(companyId)) {
4184 remove(journalArticle);
4185 }
4186 }
4187
4188 public void removeBySmallImageId(long smallImageId)
4189 throws SystemException {
4190 for (JournalArticle journalArticle : findBySmallImageId(smallImageId)) {
4191 remove(journalArticle);
4192 }
4193 }
4194
4195 public void removeByR_A(long resourcePrimKey, boolean approved)
4196 throws SystemException {
4197 for (JournalArticle journalArticle : findByR_A(resourcePrimKey, approved)) {
4198 remove(journalArticle);
4199 }
4200 }
4201
4202 public void removeByG_A(long groupId, String articleId)
4203 throws SystemException {
4204 for (JournalArticle journalArticle : findByG_A(groupId, articleId)) {
4205 remove(journalArticle);
4206 }
4207 }
4208
4209 public void removeByG_S(long groupId, String structureId)
4210 throws SystemException {
4211 for (JournalArticle journalArticle : findByG_S(groupId, structureId)) {
4212 remove(journalArticle);
4213 }
4214 }
4215
4216 public void removeByG_T(long groupId, String templateId)
4217 throws SystemException {
4218 for (JournalArticle journalArticle : findByG_T(groupId, templateId)) {
4219 remove(journalArticle);
4220 }
4221 }
4222
4223 public void removeByG_UT(long groupId, String urlTitle)
4224 throws SystemException {
4225 for (JournalArticle journalArticle : findByG_UT(groupId, urlTitle)) {
4226 remove(journalArticle);
4227 }
4228 }
4229
4230 public void removeByG_A_V(long groupId, String articleId, double version)
4231 throws NoSuchArticleException, SystemException {
4232 JournalArticle journalArticle = findByG_A_V(groupId, articleId, version);
4233
4234 remove(journalArticle);
4235 }
4236
4237 public void removeByG_A_A(long groupId, String articleId, boolean approved)
4238 throws SystemException {
4239 for (JournalArticle journalArticle : findByG_A_A(groupId, articleId,
4240 approved)) {
4241 remove(journalArticle);
4242 }
4243 }
4244
4245 public void removeByG_UT_A(long groupId, String urlTitle, boolean approved)
4246 throws SystemException {
4247 for (JournalArticle journalArticle : findByG_UT_A(groupId, urlTitle,
4248 approved)) {
4249 remove(journalArticle);
4250 }
4251 }
4252
4253 public void removeAll() throws SystemException {
4254 for (JournalArticle journalArticle : findAll()) {
4255 remove(journalArticle);
4256 }
4257 }
4258
4259 public int countByUuid(String uuid) throws SystemException {
4260 Object[] finderArgs = new Object[] { uuid };
4261
4262 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_UUID,
4263 finderArgs, this);
4264
4265 if (count == null) {
4266 StringBundler query = new StringBundler(2);
4267
4268 query.append(_SQL_COUNT_JOURNALARTICLE_WHERE);
4269
4270 if (uuid == null) {
4271 query.append(_FINDER_COLUMN_UUID_UUID_1);
4272 }
4273 else {
4274 if (uuid.equals(StringPool.BLANK)) {
4275 query.append(_FINDER_COLUMN_UUID_UUID_3);
4276 }
4277 else {
4278 query.append(_FINDER_COLUMN_UUID_UUID_2);
4279 }
4280 }
4281
4282 String sql = query.toString();
4283
4284 Session session = null;
4285
4286 try {
4287 session = openSession();
4288
4289 Query q = session.createQuery(sql);
4290
4291 QueryPos qPos = QueryPos.getInstance(q);
4292
4293 if (uuid != null) {
4294 qPos.add(uuid);
4295 }
4296
4297 count = (Long)q.uniqueResult();
4298 }
4299 catch (Exception e) {
4300 throw processException(e);
4301 }
4302 finally {
4303 if (count == null) {
4304 count = Long.valueOf(0);
4305 }
4306
4307 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID,
4308 finderArgs, count);
4309
4310 closeSession(session);
4311 }
4312 }
4313
4314 return count.intValue();
4315 }
4316
4317 public int countByUUID_G(String uuid, long groupId)
4318 throws SystemException {
4319 Object[] finderArgs = new Object[] { uuid, groupId };
4320
4321 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_UUID_G,
4322 finderArgs, this);
4323
4324 if (count == null) {
4325 StringBundler query = new StringBundler(3);
4326
4327 query.append(_SQL_COUNT_JOURNALARTICLE_WHERE);
4328
4329 if (uuid == null) {
4330 query.append(_FINDER_COLUMN_UUID_G_UUID_1);
4331 }
4332 else {
4333 if (uuid.equals(StringPool.BLANK)) {
4334 query.append(_FINDER_COLUMN_UUID_G_UUID_3);
4335 }
4336 else {
4337 query.append(_FINDER_COLUMN_UUID_G_UUID_2);
4338 }
4339 }
4340
4341 query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
4342
4343 String sql = query.toString();
4344
4345 Session session = null;
4346
4347 try {
4348 session = openSession();
4349
4350 Query q = session.createQuery(sql);
4351
4352 QueryPos qPos = QueryPos.getInstance(q);
4353
4354 if (uuid != null) {
4355 qPos.add(uuid);
4356 }
4357
4358 qPos.add(groupId);
4359
4360 count = (Long)q.uniqueResult();
4361 }
4362 catch (Exception e) {
4363 throw processException(e);
4364 }
4365 finally {
4366 if (count == null) {
4367 count = Long.valueOf(0);
4368 }
4369
4370 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID_G,
4371 finderArgs, count);
4372
4373 closeSession(session);
4374 }
4375 }
4376
4377 return count.intValue();
4378 }
4379
4380 public int countByGroupId(long groupId) throws SystemException {
4381 Object[] finderArgs = new Object[] { groupId };
4382
4383 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_GROUPID,
4384 finderArgs, this);
4385
4386 if (count == null) {
4387 StringBundler query = new StringBundler(2);
4388
4389 query.append(_SQL_COUNT_JOURNALARTICLE_WHERE);
4390
4391 query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
4392
4393 String sql = query.toString();
4394
4395 Session session = null;
4396
4397 try {
4398 session = openSession();
4399
4400 Query q = session.createQuery(sql);
4401
4402 QueryPos qPos = QueryPos.getInstance(q);
4403
4404 qPos.add(groupId);
4405
4406 count = (Long)q.uniqueResult();
4407 }
4408 catch (Exception e) {
4409 throw processException(e);
4410 }
4411 finally {
4412 if (count == null) {
4413 count = Long.valueOf(0);
4414 }
4415
4416 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_GROUPID,
4417 finderArgs, count);
4418
4419 closeSession(session);
4420 }
4421 }
4422
4423 return count.intValue();
4424 }
4425
4426 public int countByCompanyId(long companyId) throws SystemException {
4427 Object[] finderArgs = new Object[] { companyId };
4428
4429 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_COMPANYID,
4430 finderArgs, this);
4431
4432 if (count == null) {
4433 StringBundler query = new StringBundler(2);
4434
4435 query.append(_SQL_COUNT_JOURNALARTICLE_WHERE);
4436
4437 query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
4438
4439 String sql = query.toString();
4440
4441 Session session = null;
4442
4443 try {
4444 session = openSession();
4445
4446 Query q = session.createQuery(sql);
4447
4448 QueryPos qPos = QueryPos.getInstance(q);
4449
4450 qPos.add(companyId);
4451
4452 count = (Long)q.uniqueResult();
4453 }
4454 catch (Exception e) {
4455 throw processException(e);
4456 }
4457 finally {
4458 if (count == null) {
4459 count = Long.valueOf(0);
4460 }
4461
4462 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_COMPANYID,
4463 finderArgs, count);
4464
4465 closeSession(session);
4466 }
4467 }
4468
4469 return count.intValue();
4470 }
4471
4472 public int countBySmallImageId(long smallImageId) throws SystemException {
4473 Object[] finderArgs = new Object[] { smallImageId };
4474
4475 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_SMALLIMAGEID,
4476 finderArgs, this);
4477
4478 if (count == null) {
4479 StringBundler query = new StringBundler(2);
4480
4481 query.append(_SQL_COUNT_JOURNALARTICLE_WHERE);
4482
4483 query.append(_FINDER_COLUMN_SMALLIMAGEID_SMALLIMAGEID_2);
4484
4485 String sql = query.toString();
4486
4487 Session session = null;
4488
4489 try {
4490 session = openSession();
4491
4492 Query q = session.createQuery(sql);
4493
4494 QueryPos qPos = QueryPos.getInstance(q);
4495
4496 qPos.add(smallImageId);
4497
4498 count = (Long)q.uniqueResult();
4499 }
4500 catch (Exception e) {
4501 throw processException(e);
4502 }
4503 finally {
4504 if (count == null) {
4505 count = Long.valueOf(0);
4506 }
4507
4508 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_SMALLIMAGEID,
4509 finderArgs, count);
4510
4511 closeSession(session);
4512 }
4513 }
4514
4515 return count.intValue();
4516 }
4517
4518 public int countByR_A(long resourcePrimKey, boolean approved)
4519 throws SystemException {
4520 Object[] finderArgs = new Object[] { resourcePrimKey, approved };
4521
4522 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_R_A,
4523 finderArgs, this);
4524
4525 if (count == null) {
4526 StringBundler query = new StringBundler(3);
4527
4528 query.append(_SQL_COUNT_JOURNALARTICLE_WHERE);
4529
4530 query.append(_FINDER_COLUMN_R_A_RESOURCEPRIMKEY_2);
4531
4532 query.append(_FINDER_COLUMN_R_A_APPROVED_2);
4533
4534 String sql = query.toString();
4535
4536 Session session = null;
4537
4538 try {
4539 session = openSession();
4540
4541 Query q = session.createQuery(sql);
4542
4543 QueryPos qPos = QueryPos.getInstance(q);
4544
4545 qPos.add(resourcePrimKey);
4546
4547 qPos.add(approved);
4548
4549 count = (Long)q.uniqueResult();
4550 }
4551 catch (Exception e) {
4552 throw processException(e);
4553 }
4554 finally {
4555 if (count == null) {
4556 count = Long.valueOf(0);
4557 }
4558
4559 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_R_A, finderArgs,
4560 count);
4561
4562 closeSession(session);
4563 }
4564 }
4565
4566 return count.intValue();
4567 }
4568
4569 public int countByG_A(long groupId, String articleId)
4570 throws SystemException {
4571 Object[] finderArgs = new Object[] { groupId, articleId };
4572
4573 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_A,
4574 finderArgs, this);
4575
4576 if (count == null) {
4577 StringBundler query = new StringBundler(3);
4578
4579 query.append(_SQL_COUNT_JOURNALARTICLE_WHERE);
4580
4581 query.append(_FINDER_COLUMN_G_A_GROUPID_2);
4582
4583 if (articleId == null) {
4584 query.append(_FINDER_COLUMN_G_A_ARTICLEID_1);
4585 }
4586 else {
4587 if (articleId.equals(StringPool.BLANK)) {
4588 query.append(_FINDER_COLUMN_G_A_ARTICLEID_3);
4589 }
4590 else {
4591 query.append(_FINDER_COLUMN_G_A_ARTICLEID_2);
4592 }
4593 }
4594
4595 String sql = query.toString();
4596
4597 Session session = null;
4598
4599 try {
4600 session = openSession();
4601
4602 Query q = session.createQuery(sql);
4603
4604 QueryPos qPos = QueryPos.getInstance(q);
4605
4606 qPos.add(groupId);
4607
4608 if (articleId != null) {
4609 qPos.add(articleId);
4610 }
4611
4612 count = (Long)q.uniqueResult();
4613 }
4614 catch (Exception e) {
4615 throw processException(e);
4616 }
4617 finally {
4618 if (count == null) {
4619 count = Long.valueOf(0);
4620 }
4621
4622 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_A, finderArgs,
4623 count);
4624
4625 closeSession(session);
4626 }
4627 }
4628
4629 return count.intValue();
4630 }
4631
4632 public int countByG_S(long groupId, String structureId)
4633 throws SystemException {
4634 Object[] finderArgs = new Object[] { groupId, structureId };
4635
4636 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_S,
4637 finderArgs, this);
4638
4639 if (count == null) {
4640 StringBundler query = new StringBundler(3);
4641
4642 query.append(_SQL_COUNT_JOURNALARTICLE_WHERE);
4643
4644 query.append(_FINDER_COLUMN_G_S_GROUPID_2);
4645
4646 if (structureId == null) {
4647 query.append(_FINDER_COLUMN_G_S_STRUCTUREID_1);
4648 }
4649 else {
4650 if (structureId.equals(StringPool.BLANK)) {
4651 query.append(_FINDER_COLUMN_G_S_STRUCTUREID_3);
4652 }
4653 else {
4654 query.append(_FINDER_COLUMN_G_S_STRUCTUREID_2);
4655 }
4656 }
4657
4658 String sql = query.toString();
4659
4660 Session session = null;
4661
4662 try {
4663 session = openSession();
4664
4665 Query q = session.createQuery(sql);
4666
4667 QueryPos qPos = QueryPos.getInstance(q);
4668
4669 qPos.add(groupId);
4670
4671 if (structureId != null) {
4672 qPos.add(structureId);
4673 }
4674
4675 count = (Long)q.uniqueResult();
4676 }
4677 catch (Exception e) {
4678 throw processException(e);
4679 }
4680 finally {
4681 if (count == null) {
4682 count = Long.valueOf(0);
4683 }
4684
4685 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_S, finderArgs,
4686 count);
4687
4688 closeSession(session);
4689 }
4690 }
4691
4692 return count.intValue();
4693 }
4694
4695 public int countByG_T(long groupId, String templateId)
4696 throws SystemException {
4697 Object[] finderArgs = new Object[] { groupId, templateId };
4698
4699 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_T,
4700 finderArgs, this);
4701
4702 if (count == null) {
4703 StringBundler query = new StringBundler(3);
4704
4705 query.append(_SQL_COUNT_JOURNALARTICLE_WHERE);
4706
4707 query.append(_FINDER_COLUMN_G_T_GROUPID_2);
4708
4709 if (templateId == null) {
4710 query.append(_FINDER_COLUMN_G_T_TEMPLATEID_1);
4711 }
4712 else {
4713 if (templateId.equals(StringPool.BLANK)) {
4714 query.append(_FINDER_COLUMN_G_T_TEMPLATEID_3);
4715 }
4716 else {
4717 query.append(_FINDER_COLUMN_G_T_TEMPLATEID_2);
4718 }
4719 }
4720
4721 String sql = query.toString();
4722
4723 Session session = null;
4724
4725 try {
4726 session = openSession();
4727
4728 Query q = session.createQuery(sql);
4729
4730 QueryPos qPos = QueryPos.getInstance(q);
4731
4732 qPos.add(groupId);
4733
4734 if (templateId != null) {
4735 qPos.add(templateId);
4736 }
4737
4738 count = (Long)q.uniqueResult();
4739 }
4740 catch (Exception e) {
4741 throw processException(e);
4742 }
4743 finally {
4744 if (count == null) {
4745 count = Long.valueOf(0);
4746 }
4747
4748 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_T, finderArgs,
4749 count);
4750
4751 closeSession(session);
4752 }
4753 }
4754
4755 return count.intValue();
4756 }
4757
4758 public int countByG_UT(long groupId, String urlTitle)
4759 throws SystemException {
4760 Object[] finderArgs = new Object[] { groupId, urlTitle };
4761
4762 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_UT,
4763 finderArgs, this);
4764
4765 if (count == null) {
4766 StringBundler query = new StringBundler(3);
4767
4768 query.append(_SQL_COUNT_JOURNALARTICLE_WHERE);
4769
4770 query.append(_FINDER_COLUMN_G_UT_GROUPID_2);
4771
4772 if (urlTitle == null) {
4773 query.append(_FINDER_COLUMN_G_UT_URLTITLE_1);
4774 }
4775 else {
4776 if (urlTitle.equals(StringPool.BLANK)) {
4777 query.append(_FINDER_COLUMN_G_UT_URLTITLE_3);
4778 }
4779 else {
4780 query.append(_FINDER_COLUMN_G_UT_URLTITLE_2);
4781 }
4782 }
4783
4784 String sql = query.toString();
4785
4786 Session session = null;
4787
4788 try {
4789 session = openSession();
4790
4791 Query q = session.createQuery(sql);
4792
4793 QueryPos qPos = QueryPos.getInstance(q);
4794
4795 qPos.add(groupId);
4796
4797 if (urlTitle != null) {
4798 qPos.add(urlTitle);
4799 }
4800
4801 count = (Long)q.uniqueResult();
4802 }
4803 catch (Exception e) {
4804 throw processException(e);
4805 }
4806 finally {
4807 if (count == null) {
4808 count = Long.valueOf(0);
4809 }
4810
4811 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_UT,
4812 finderArgs, count);
4813
4814 closeSession(session);
4815 }
4816 }
4817
4818 return count.intValue();
4819 }
4820
4821 public int countByG_A_V(long groupId, String articleId, double version)
4822 throws SystemException {
4823 Object[] finderArgs = new Object[] { groupId, articleId, version };
4824
4825 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_A_V,
4826 finderArgs, this);
4827
4828 if (count == null) {
4829 StringBundler query = new StringBundler(4);
4830
4831 query.append(_SQL_COUNT_JOURNALARTICLE_WHERE);
4832
4833 query.append(_FINDER_COLUMN_G_A_V_GROUPID_2);
4834
4835 if (articleId == null) {
4836 query.append(_FINDER_COLUMN_G_A_V_ARTICLEID_1);
4837 }
4838 else {
4839 if (articleId.equals(StringPool.BLANK)) {
4840 query.append(_FINDER_COLUMN_G_A_V_ARTICLEID_3);
4841 }
4842 else {
4843 query.append(_FINDER_COLUMN_G_A_V_ARTICLEID_2);
4844 }
4845 }
4846
4847 query.append(_FINDER_COLUMN_G_A_V_VERSION_2);
4848
4849 String sql = query.toString();
4850
4851 Session session = null;
4852
4853 try {
4854 session = openSession();
4855
4856 Query q = session.createQuery(sql);
4857
4858 QueryPos qPos = QueryPos.getInstance(q);
4859
4860 qPos.add(groupId);
4861
4862 if (articleId != null) {
4863 qPos.add(articleId);
4864 }
4865
4866 qPos.add(version);
4867
4868 count = (Long)q.uniqueResult();
4869 }
4870 catch (Exception e) {
4871 throw processException(e);
4872 }
4873 finally {
4874 if (count == null) {
4875 count = Long.valueOf(0);
4876 }
4877
4878 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_A_V,
4879 finderArgs, count);
4880
4881 closeSession(session);
4882 }
4883 }
4884
4885 return count.intValue();
4886 }
4887
4888 public int countByG_A_A(long groupId, String articleId, boolean approved)
4889 throws SystemException {
4890 Object[] finderArgs = new Object[] { groupId, articleId, approved };
4891
4892 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_A_A,
4893 finderArgs, this);
4894
4895 if (count == null) {
4896 StringBundler query = new StringBundler(4);
4897
4898 query.append(_SQL_COUNT_JOURNALARTICLE_WHERE);
4899
4900 query.append(_FINDER_COLUMN_G_A_A_GROUPID_2);
4901
4902 if (articleId == null) {
4903 query.append(_FINDER_COLUMN_G_A_A_ARTICLEID_1);
4904 }
4905 else {
4906 if (articleId.equals(StringPool.BLANK)) {
4907 query.append(_FINDER_COLUMN_G_A_A_ARTICLEID_3);
4908 }
4909 else {
4910 query.append(_FINDER_COLUMN_G_A_A_ARTICLEID_2);
4911 }
4912 }
4913
4914 query.append(_FINDER_COLUMN_G_A_A_APPROVED_2);
4915
4916 String sql = query.toString();
4917
4918 Session session = null;
4919
4920 try {
4921 session = openSession();
4922
4923 Query q = session.createQuery(sql);
4924
4925 QueryPos qPos = QueryPos.getInstance(q);
4926
4927 qPos.add(groupId);
4928
4929 if (articleId != null) {
4930 qPos.add(articleId);
4931 }
4932
4933 qPos.add(approved);
4934
4935 count = (Long)q.uniqueResult();
4936 }
4937 catch (Exception e) {
4938 throw processException(e);
4939 }
4940 finally {
4941 if (count == null) {
4942 count = Long.valueOf(0);
4943 }
4944
4945 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_A_A,
4946 finderArgs, count);
4947
4948 closeSession(session);
4949 }
4950 }
4951
4952 return count.intValue();
4953 }
4954
4955 public int countByG_UT_A(long groupId, String urlTitle, boolean approved)
4956 throws SystemException {
4957 Object[] finderArgs = new Object[] { groupId, urlTitle, approved };
4958
4959 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_UT_A,
4960 finderArgs, this);
4961
4962 if (count == null) {
4963 StringBundler query = new StringBundler(4);
4964
4965 query.append(_SQL_COUNT_JOURNALARTICLE_WHERE);
4966
4967 query.append(_FINDER_COLUMN_G_UT_A_GROUPID_2);
4968
4969 if (urlTitle == null) {
4970 query.append(_FINDER_COLUMN_G_UT_A_URLTITLE_1);
4971 }
4972 else {
4973 if (urlTitle.equals(StringPool.BLANK)) {
4974 query.append(_FINDER_COLUMN_G_UT_A_URLTITLE_3);
4975 }
4976 else {
4977 query.append(_FINDER_COLUMN_G_UT_A_URLTITLE_2);
4978 }
4979 }
4980
4981 query.append(_FINDER_COLUMN_G_UT_A_APPROVED_2);
4982
4983 String sql = query.toString();
4984
4985 Session session = null;
4986
4987 try {
4988 session = openSession();
4989
4990 Query q = session.createQuery(sql);
4991
4992 QueryPos qPos = QueryPos.getInstance(q);
4993
4994 qPos.add(groupId);
4995
4996 if (urlTitle != null) {
4997 qPos.add(urlTitle);
4998 }
4999
5000 qPos.add(approved);
5001
5002 count = (Long)q.uniqueResult();
5003 }
5004 catch (Exception e) {
5005 throw processException(e);
5006 }
5007 finally {
5008 if (count == null) {
5009 count = Long.valueOf(0);
5010 }
5011
5012 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_UT_A,
5013 finderArgs, count);
5014
5015 closeSession(session);
5016 }
5017 }
5018
5019 return count.intValue();
5020 }
5021
5022 public int countAll() throws SystemException {
5023 Object[] finderArgs = new Object[0];
5024
5025 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
5026 finderArgs, this);
5027
5028 if (count == null) {
5029 Session session = null;
5030
5031 try {
5032 session = openSession();
5033
5034 Query q = session.createQuery(_SQL_COUNT_JOURNALARTICLE);
5035
5036 count = (Long)q.uniqueResult();
5037 }
5038 catch (Exception e) {
5039 throw processException(e);
5040 }
5041 finally {
5042 if (count == null) {
5043 count = Long.valueOf(0);
5044 }
5045
5046 FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
5047 count);
5048
5049 closeSession(session);
5050 }
5051 }
5052
5053 return count.intValue();
5054 }
5055
5056 public void afterPropertiesSet() {
5057 String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
5058 com.liferay.portal.util.PropsUtil.get(
5059 "value.object.listener.com.liferay.portlet.journal.model.JournalArticle")));
5060
5061 if (listenerClassNames.length > 0) {
5062 try {
5063 List<ModelListener<JournalArticle>> listenersList = new ArrayList<ModelListener<JournalArticle>>();
5064
5065 for (String listenerClassName : listenerClassNames) {
5066 listenersList.add((ModelListener<JournalArticle>)InstanceFactory.newInstance(
5067 listenerClassName));
5068 }
5069
5070 listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
5071 }
5072 catch (Exception e) {
5073 _log.error(e);
5074 }
5075 }
5076 }
5077
5078 public void destroy() {
5079 EntityCacheUtil.removeCache(JournalArticleImpl.class.getName());
5080 FinderCacheUtil.removeCache(FINDER_CLASS_NAME_ENTITY);
5081 FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST);
5082 }
5083
5084 @BeanReference(type = JournalArticlePersistence.class)
5085 protected JournalArticlePersistence journalArticlePersistence;
5086 @BeanReference(type = JournalArticleImagePersistence.class)
5087 protected JournalArticleImagePersistence journalArticleImagePersistence;
5088 @BeanReference(type = JournalArticleResourcePersistence.class)
5089 protected JournalArticleResourcePersistence journalArticleResourcePersistence;
5090 @BeanReference(type = JournalContentSearchPersistence.class)
5091 protected JournalContentSearchPersistence journalContentSearchPersistence;
5092 @BeanReference(type = JournalFeedPersistence.class)
5093 protected JournalFeedPersistence journalFeedPersistence;
5094 @BeanReference(type = JournalStructurePersistence.class)
5095 protected JournalStructurePersistence journalStructurePersistence;
5096 @BeanReference(type = JournalTemplatePersistence.class)
5097 protected JournalTemplatePersistence journalTemplatePersistence;
5098 @BeanReference(type = CompanyPersistence.class)
5099 protected CompanyPersistence companyPersistence;
5100 @BeanReference(type = ImagePersistence.class)
5101 protected ImagePersistence imagePersistence;
5102 @BeanReference(type = PortletPreferencesPersistence.class)
5103 protected PortletPreferencesPersistence portletPreferencesPersistence;
5104 @BeanReference(type = ResourcePersistence.class)
5105 protected ResourcePersistence resourcePersistence;
5106 @BeanReference(type = UserPersistence.class)
5107 protected UserPersistence userPersistence;
5108 @BeanReference(type = ExpandoValuePersistence.class)
5109 protected ExpandoValuePersistence expandoValuePersistence;
5110 @BeanReference(type = MBMessagePersistence.class)
5111 protected MBMessagePersistence mbMessagePersistence;
5112 @BeanReference(type = RatingsStatsPersistence.class)
5113 protected RatingsStatsPersistence ratingsStatsPersistence;
5114 @BeanReference(type = TagsAssetPersistence.class)
5115 protected TagsAssetPersistence tagsAssetPersistence;
5116 @BeanReference(type = TagsEntryPersistence.class)
5117 protected TagsEntryPersistence tagsEntryPersistence;
5118 private static final String _SQL_SELECT_JOURNALARTICLE = "SELECT journalArticle FROM JournalArticle journalArticle";
5119 private static final String _SQL_SELECT_JOURNALARTICLE_WHERE = "SELECT journalArticle FROM JournalArticle journalArticle WHERE ";
5120 private static final String _SQL_COUNT_JOURNALARTICLE = "SELECT COUNT(journalArticle) FROM JournalArticle journalArticle";
5121 private static final String _SQL_COUNT_JOURNALARTICLE_WHERE = "SELECT COUNT(journalArticle) FROM JournalArticle journalArticle WHERE ";
5122 private static final String _FINDER_COLUMN_UUID_UUID_1 = "journalArticle.uuid IS NULL";
5123 private static final String _FINDER_COLUMN_UUID_UUID_2 = "journalArticle.uuid = ?";
5124 private static final String _FINDER_COLUMN_UUID_UUID_3 = "(journalArticle.uuid IS NULL OR journalArticle.uuid = ?)";
5125 private static final String _FINDER_COLUMN_UUID_G_UUID_1 = "journalArticle.uuid IS NULL AND ";
5126 private static final String _FINDER_COLUMN_UUID_G_UUID_2 = "journalArticle.uuid = ? AND ";
5127 private static final String _FINDER_COLUMN_UUID_G_UUID_3 = "(journalArticle.uuid IS NULL OR journalArticle.uuid = ?) AND ";
5128 private static final String _FINDER_COLUMN_UUID_G_GROUPID_2 = "journalArticle.groupId = ?";
5129 private static final String _FINDER_COLUMN_GROUPID_GROUPID_2 = "journalArticle.groupId = ?";
5130 private static final String _FINDER_COLUMN_COMPANYID_COMPANYID_2 = "journalArticle.companyId = ?";
5131 private static final String _FINDER_COLUMN_SMALLIMAGEID_SMALLIMAGEID_2 = "journalArticle.smallImageId = ?";
5132 private static final String _FINDER_COLUMN_R_A_RESOURCEPRIMKEY_2 = "journalArticle.resourcePrimKey = ? AND ";
5133 private static final String _FINDER_COLUMN_R_A_APPROVED_2 = "journalArticle.approved = ?";
5134 private static final String _FINDER_COLUMN_G_A_GROUPID_2 = "journalArticle.groupId = ? AND ";
5135 private static final String _FINDER_COLUMN_G_A_ARTICLEID_1 = "journalArticle.articleId IS NULL";
5136 private static final String _FINDER_COLUMN_G_A_ARTICLEID_2 = "journalArticle.articleId = ?";
5137 private static final String _FINDER_COLUMN_G_A_ARTICLEID_3 = "(journalArticle.articleId IS NULL OR journalArticle.articleId = ?)";
5138 private static final String _FINDER_COLUMN_G_S_GROUPID_2 = "journalArticle.groupId = ? AND ";
5139 private static final String _FINDER_COLUMN_G_S_STRUCTUREID_1 = "journalArticle.structureId IS NULL";
5140 private static final String _FINDER_COLUMN_G_S_STRUCTUREID_2 = "journalArticle.structureId = ?";
5141 private static final String _FINDER_COLUMN_G_S_STRUCTUREID_3 = "(journalArticle.structureId IS NULL OR journalArticle.structureId = ?)";
5142 private static final String _FINDER_COLUMN_G_T_GROUPID_2 = "journalArticle.groupId = ? AND ";
5143 private static final String _FINDER_COLUMN_G_T_TEMPLATEID_1 = "journalArticle.templateId IS NULL";
5144 private static final String _FINDER_COLUMN_G_T_TEMPLATEID_2 = "journalArticle.templateId = ?";
5145 private static final String _FINDER_COLUMN_G_T_TEMPLATEID_3 = "(journalArticle.templateId IS NULL OR journalArticle.templateId = ?)";
5146 private static final String _FINDER_COLUMN_G_UT_GROUPID_2 = "journalArticle.groupId = ? AND ";
5147 private static final String _FINDER_COLUMN_G_UT_URLTITLE_1 = "journalArticle.urlTitle IS NULL";
5148 private static final String _FINDER_COLUMN_G_UT_URLTITLE_2 = "journalArticle.urlTitle = ?";
5149 private static final String _FINDER_COLUMN_G_UT_URLTITLE_3 = "(journalArticle.urlTitle IS NULL OR journalArticle.urlTitle = ?)";
5150 private static final String _FINDER_COLUMN_G_A_V_GROUPID_2 = "journalArticle.groupId = ? AND ";
5151 private static final String _FINDER_COLUMN_G_A_V_ARTICLEID_1 = "journalArticle.articleId IS NULL AND ";
5152 private static final String _FINDER_COLUMN_G_A_V_ARTICLEID_2 = "journalArticle.articleId = ? AND ";
5153 private static final String _FINDER_COLUMN_G_A_V_ARTICLEID_3 = "(journalArticle.articleId IS NULL OR journalArticle.articleId = ?) AND ";
5154 private static final String _FINDER_COLUMN_G_A_V_VERSION_2 = "journalArticle.version = ?";
5155 private static final String _FINDER_COLUMN_G_A_A_GROUPID_2 = "journalArticle.groupId = ? AND ";
5156 private static final String _FINDER_COLUMN_G_A_A_ARTICLEID_1 = "journalArticle.articleId IS NULL AND ";
5157 private static final String _FINDER_COLUMN_G_A_A_ARTICLEID_2 = "journalArticle.articleId = ? AND ";
5158 private static final String _FINDER_COLUMN_G_A_A_ARTICLEID_3 = "(journalArticle.articleId IS NULL OR journalArticle.articleId = ?) AND ";
5159 private static final String _FINDER_COLUMN_G_A_A_APPROVED_2 = "journalArticle.approved = ?";
5160 private static final String _FINDER_COLUMN_G_UT_A_GROUPID_2 = "journalArticle.groupId = ? AND ";
5161 private static final String _FINDER_COLUMN_G_UT_A_URLTITLE_1 = "journalArticle.urlTitle IS NULL AND ";
5162 private static final String _FINDER_COLUMN_G_UT_A_URLTITLE_2 = "journalArticle.urlTitle = ? AND ";
5163 private static final String _FINDER_COLUMN_G_UT_A_URLTITLE_3 = "(journalArticle.urlTitle IS NULL OR journalArticle.urlTitle = ?) AND ";
5164 private static final String _FINDER_COLUMN_G_UT_A_APPROVED_2 = "journalArticle.approved = ?";
5165 private static final String _ORDER_BY_ENTITY_ALIAS = "journalArticle.";
5166 private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No JournalArticle exists with the primary key ";
5167 private static final String _NO_SUCH_ENTITY_WITH_KEY = "No JournalArticle exists with the key {";
5168 private static Log _log = LogFactoryUtil.getLog(JournalArticlePersistenceImpl.class);
5169}