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