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