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