1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * The contents of this file are subject to the terms of the Liferay Enterprise
5    * Subscription License ("License"). You may not use this file except in
6    * compliance with the License. You can obtain a copy of the License by
7    * contacting Liferay, Inc. See the License for the specific language governing
8    * permissions and limitations under the License, including but not limited to
9    * distribution rights of the Software.
10   *
11   *
12   * 
13   */
14  
15  package com.liferay.portlet.announcements.service.persistence;
16  
17  import com.liferay.portal.NoSuchModelException;
18  import com.liferay.portal.SystemException;
19  import com.liferay.portal.kernel.annotation.BeanReference;
20  import com.liferay.portal.kernel.cache.CacheRegistry;
21  import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
22  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
23  import com.liferay.portal.kernel.dao.orm.FinderPath;
24  import com.liferay.portal.kernel.dao.orm.Query;
25  import com.liferay.portal.kernel.dao.orm.QueryPos;
26  import com.liferay.portal.kernel.dao.orm.QueryUtil;
27  import com.liferay.portal.kernel.dao.orm.Session;
28  import com.liferay.portal.kernel.log.Log;
29  import com.liferay.portal.kernel.log.LogFactoryUtil;
30  import com.liferay.portal.kernel.util.GetterUtil;
31  import com.liferay.portal.kernel.util.OrderByComparator;
32  import com.liferay.portal.kernel.util.StringBundler;
33  import com.liferay.portal.kernel.util.StringPool;
34  import com.liferay.portal.kernel.util.StringUtil;
35  import com.liferay.portal.model.ModelListener;
36  import com.liferay.portal.service.persistence.BatchSessionUtil;
37  import com.liferay.portal.service.persistence.ResourcePersistence;
38  import com.liferay.portal.service.persistence.UserPersistence;
39  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
40  
41  import com.liferay.portlet.announcements.NoSuchFlagException;
42  import com.liferay.portlet.announcements.model.AnnouncementsFlag;
43  import com.liferay.portlet.announcements.model.impl.AnnouncementsFlagImpl;
44  import com.liferay.portlet.announcements.model.impl.AnnouncementsFlagModelImpl;
45  
46  import java.io.Serializable;
47  
48  import java.util.ArrayList;
49  import java.util.Collections;
50  import java.util.List;
51  
52  /**
53   * <a href="AnnouncementsFlagPersistenceImpl.java.html"><b><i>View Source</i></b></a>
54   *
55   * <p>
56   * ServiceBuilder generated this class. Modifications in this class will be
57   * overwritten the next time is generated.
58   * </p>
59   *
60   * @author    Brian Wing Shun Chan
61   * @see       AnnouncementsFlagPersistence
62   * @see       AnnouncementsFlagUtil
63   * @generated
64   */
65  public class AnnouncementsFlagPersistenceImpl extends BasePersistenceImpl<AnnouncementsFlag>
66      implements AnnouncementsFlagPersistence {
67      public static final String FINDER_CLASS_NAME_ENTITY = AnnouncementsFlagImpl.class.getName();
68      public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
69          ".List";
70      public static final FinderPath FINDER_PATH_FIND_BY_ENTRYID = new FinderPath(AnnouncementsFlagModelImpl.ENTITY_CACHE_ENABLED,
71              AnnouncementsFlagModelImpl.FINDER_CACHE_ENABLED,
72              FINDER_CLASS_NAME_LIST, "findByEntryId",
73              new String[] { Long.class.getName() });
74      public static final FinderPath FINDER_PATH_FIND_BY_OBC_ENTRYID = new FinderPath(AnnouncementsFlagModelImpl.ENTITY_CACHE_ENABLED,
75              AnnouncementsFlagModelImpl.FINDER_CACHE_ENABLED,
76              FINDER_CLASS_NAME_LIST, "findByEntryId",
77              new String[] {
78                  Long.class.getName(),
79                  
80              "java.lang.Integer", "java.lang.Integer",
81                  "com.liferay.portal.kernel.util.OrderByComparator"
82              });
83      public static final FinderPath FINDER_PATH_COUNT_BY_ENTRYID = new FinderPath(AnnouncementsFlagModelImpl.ENTITY_CACHE_ENABLED,
84              AnnouncementsFlagModelImpl.FINDER_CACHE_ENABLED,
85              FINDER_CLASS_NAME_LIST, "countByEntryId",
86              new String[] { Long.class.getName() });
87      public static final FinderPath FINDER_PATH_FETCH_BY_U_E_V = new FinderPath(AnnouncementsFlagModelImpl.ENTITY_CACHE_ENABLED,
88              AnnouncementsFlagModelImpl.FINDER_CACHE_ENABLED,
89              FINDER_CLASS_NAME_ENTITY, "fetchByU_E_V",
90              new String[] {
91                  Long.class.getName(), Long.class.getName(),
92                  Integer.class.getName()
93              });
94      public static final FinderPath FINDER_PATH_COUNT_BY_U_E_V = new FinderPath(AnnouncementsFlagModelImpl.ENTITY_CACHE_ENABLED,
95              AnnouncementsFlagModelImpl.FINDER_CACHE_ENABLED,
96              FINDER_CLASS_NAME_LIST, "countByU_E_V",
97              new String[] {
98                  Long.class.getName(), Long.class.getName(),
99                  Integer.class.getName()
100             });
101     public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(AnnouncementsFlagModelImpl.ENTITY_CACHE_ENABLED,
102             AnnouncementsFlagModelImpl.FINDER_CACHE_ENABLED,
103             FINDER_CLASS_NAME_LIST, "findAll", new String[0]);
104     public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(AnnouncementsFlagModelImpl.ENTITY_CACHE_ENABLED,
105             AnnouncementsFlagModelImpl.FINDER_CACHE_ENABLED,
106             FINDER_CLASS_NAME_LIST, "countAll", new String[0]);
107 
108     public void cacheResult(AnnouncementsFlag announcementsFlag) {
109         EntityCacheUtil.putResult(AnnouncementsFlagModelImpl.ENTITY_CACHE_ENABLED,
110             AnnouncementsFlagImpl.class, announcementsFlag.getPrimaryKey(),
111             announcementsFlag);
112 
113         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_U_E_V,
114             new Object[] {
115                 new Long(announcementsFlag.getUserId()),
116                 new Long(announcementsFlag.getEntryId()),
117                 new Integer(announcementsFlag.getValue())
118             }, announcementsFlag);
119     }
120 
121     public void cacheResult(List<AnnouncementsFlag> announcementsFlags) {
122         for (AnnouncementsFlag announcementsFlag : announcementsFlags) {
123             if (EntityCacheUtil.getResult(
124                         AnnouncementsFlagModelImpl.ENTITY_CACHE_ENABLED,
125                         AnnouncementsFlagImpl.class,
126                         announcementsFlag.getPrimaryKey(), this) == null) {
127                 cacheResult(announcementsFlag);
128             }
129         }
130     }
131 
132     public void clearCache() {
133         CacheRegistry.clear(AnnouncementsFlagImpl.class.getName());
134         EntityCacheUtil.clearCache(AnnouncementsFlagImpl.class.getName());
135         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
136         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
137     }
138 
139     public AnnouncementsFlag create(long flagId) {
140         AnnouncementsFlag announcementsFlag = new AnnouncementsFlagImpl();
141 
142         announcementsFlag.setNew(true);
143         announcementsFlag.setPrimaryKey(flagId);
144 
145         return announcementsFlag;
146     }
147 
148     public AnnouncementsFlag remove(Serializable primaryKey)
149         throws NoSuchModelException, SystemException {
150         return remove(((Long)primaryKey).longValue());
151     }
152 
153     public AnnouncementsFlag remove(long flagId)
154         throws NoSuchFlagException, SystemException {
155         Session session = null;
156 
157         try {
158             session = openSession();
159 
160             AnnouncementsFlag announcementsFlag = (AnnouncementsFlag)session.get(AnnouncementsFlagImpl.class,
161                     new Long(flagId));
162 
163             if (announcementsFlag == null) {
164                 if (_log.isWarnEnabled()) {
165                     _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + flagId);
166                 }
167 
168                 throw new NoSuchFlagException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
169                     flagId);
170             }
171 
172             return remove(announcementsFlag);
173         }
174         catch (NoSuchFlagException nsee) {
175             throw nsee;
176         }
177         catch (Exception e) {
178             throw processException(e);
179         }
180         finally {
181             closeSession(session);
182         }
183     }
184 
185     public AnnouncementsFlag remove(AnnouncementsFlag announcementsFlag)
186         throws SystemException {
187         for (ModelListener<AnnouncementsFlag> listener : listeners) {
188             listener.onBeforeRemove(announcementsFlag);
189         }
190 
191         announcementsFlag = removeImpl(announcementsFlag);
192 
193         for (ModelListener<AnnouncementsFlag> listener : listeners) {
194             listener.onAfterRemove(announcementsFlag);
195         }
196 
197         return announcementsFlag;
198     }
199 
200     protected AnnouncementsFlag removeImpl(AnnouncementsFlag announcementsFlag)
201         throws SystemException {
202         announcementsFlag = toUnwrappedModel(announcementsFlag);
203 
204         Session session = null;
205 
206         try {
207             session = openSession();
208 
209             if (announcementsFlag.isCachedModel() ||
210                     BatchSessionUtil.isEnabled()) {
211                 Object staleObject = session.get(AnnouncementsFlagImpl.class,
212                         announcementsFlag.getPrimaryKeyObj());
213 
214                 if (staleObject != null) {
215                     session.evict(staleObject);
216                 }
217             }
218 
219             session.delete(announcementsFlag);
220 
221             session.flush();
222         }
223         catch (Exception e) {
224             throw processException(e);
225         }
226         finally {
227             closeSession(session);
228         }
229 
230         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
231 
232         AnnouncementsFlagModelImpl announcementsFlagModelImpl = (AnnouncementsFlagModelImpl)announcementsFlag;
233 
234         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_U_E_V,
235             new Object[] {
236                 new Long(announcementsFlagModelImpl.getOriginalUserId()),
237                 new Long(announcementsFlagModelImpl.getOriginalEntryId()),
238                 new Integer(announcementsFlagModelImpl.getOriginalValue())
239             });
240 
241         EntityCacheUtil.removeResult(AnnouncementsFlagModelImpl.ENTITY_CACHE_ENABLED,
242             AnnouncementsFlagImpl.class, announcementsFlag.getPrimaryKey());
243 
244         return announcementsFlag;
245     }
246 
247     /**
248      * @deprecated Use {@link BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)}.
249      */
250     public AnnouncementsFlag update(AnnouncementsFlag announcementsFlag)
251         throws SystemException {
252         if (_log.isWarnEnabled()) {
253             _log.warn(
254                 "Using the deprecated update(AnnouncementsFlag announcementsFlag) method. Use update(AnnouncementsFlag announcementsFlag, boolean merge) instead.");
255         }
256 
257         return update(announcementsFlag, false);
258     }
259 
260     public AnnouncementsFlag updateImpl(
261         com.liferay.portlet.announcements.model.AnnouncementsFlag announcementsFlag,
262         boolean merge) throws SystemException {
263         announcementsFlag = toUnwrappedModel(announcementsFlag);
264 
265         boolean isNew = announcementsFlag.isNew();
266 
267         AnnouncementsFlagModelImpl announcementsFlagModelImpl = (AnnouncementsFlagModelImpl)announcementsFlag;
268 
269         Session session = null;
270 
271         try {
272             session = openSession();
273 
274             BatchSessionUtil.update(session, announcementsFlag, merge);
275 
276             announcementsFlag.setNew(false);
277         }
278         catch (Exception e) {
279             throw processException(e);
280         }
281         finally {
282             closeSession(session);
283         }
284 
285         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
286 
287         EntityCacheUtil.putResult(AnnouncementsFlagModelImpl.ENTITY_CACHE_ENABLED,
288             AnnouncementsFlagImpl.class, announcementsFlag.getPrimaryKey(),
289             announcementsFlag);
290 
291         if (!isNew &&
292                 ((announcementsFlag.getUserId() != announcementsFlagModelImpl.getOriginalUserId()) ||
293                 (announcementsFlag.getEntryId() != announcementsFlagModelImpl.getOriginalEntryId()) ||
294                 (announcementsFlag.getValue() != announcementsFlagModelImpl.getOriginalValue()))) {
295             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_U_E_V,
296                 new Object[] {
297                     new Long(announcementsFlagModelImpl.getOriginalUserId()),
298                     new Long(announcementsFlagModelImpl.getOriginalEntryId()),
299                     new Integer(announcementsFlagModelImpl.getOriginalValue())
300                 });
301         }
302 
303         if (isNew ||
304                 ((announcementsFlag.getUserId() != announcementsFlagModelImpl.getOriginalUserId()) ||
305                 (announcementsFlag.getEntryId() != announcementsFlagModelImpl.getOriginalEntryId()) ||
306                 (announcementsFlag.getValue() != announcementsFlagModelImpl.getOriginalValue()))) {
307             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_U_E_V,
308                 new Object[] {
309                     new Long(announcementsFlag.getUserId()),
310                     new Long(announcementsFlag.getEntryId()),
311                     new Integer(announcementsFlag.getValue())
312                 }, announcementsFlag);
313         }
314 
315         return announcementsFlag;
316     }
317 
318     protected AnnouncementsFlag toUnwrappedModel(
319         AnnouncementsFlag announcementsFlag) {
320         if (announcementsFlag instanceof AnnouncementsFlagImpl) {
321             return announcementsFlag;
322         }
323 
324         AnnouncementsFlagImpl announcementsFlagImpl = new AnnouncementsFlagImpl();
325 
326         announcementsFlagImpl.setNew(announcementsFlag.isNew());
327         announcementsFlagImpl.setPrimaryKey(announcementsFlag.getPrimaryKey());
328 
329         announcementsFlagImpl.setFlagId(announcementsFlag.getFlagId());
330         announcementsFlagImpl.setUserId(announcementsFlag.getUserId());
331         announcementsFlagImpl.setCreateDate(announcementsFlag.getCreateDate());
332         announcementsFlagImpl.setEntryId(announcementsFlag.getEntryId());
333         announcementsFlagImpl.setValue(announcementsFlag.getValue());
334 
335         return announcementsFlagImpl;
336     }
337 
338     public AnnouncementsFlag findByPrimaryKey(Serializable primaryKey)
339         throws NoSuchModelException, SystemException {
340         return findByPrimaryKey(((Long)primaryKey).longValue());
341     }
342 
343     public AnnouncementsFlag findByPrimaryKey(long flagId)
344         throws NoSuchFlagException, SystemException {
345         AnnouncementsFlag announcementsFlag = fetchByPrimaryKey(flagId);
346 
347         if (announcementsFlag == null) {
348             if (_log.isWarnEnabled()) {
349                 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + flagId);
350             }
351 
352             throw new NoSuchFlagException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
353                 flagId);
354         }
355 
356         return announcementsFlag;
357     }
358 
359     public AnnouncementsFlag fetchByPrimaryKey(Serializable primaryKey)
360         throws SystemException {
361         return fetchByPrimaryKey(((Long)primaryKey).longValue());
362     }
363 
364     public AnnouncementsFlag fetchByPrimaryKey(long flagId)
365         throws SystemException {
366         AnnouncementsFlag announcementsFlag = (AnnouncementsFlag)EntityCacheUtil.getResult(AnnouncementsFlagModelImpl.ENTITY_CACHE_ENABLED,
367                 AnnouncementsFlagImpl.class, flagId, this);
368 
369         if (announcementsFlag == null) {
370             Session session = null;
371 
372             try {
373                 session = openSession();
374 
375                 announcementsFlag = (AnnouncementsFlag)session.get(AnnouncementsFlagImpl.class,
376                         new Long(flagId));
377             }
378             catch (Exception e) {
379                 throw processException(e);
380             }
381             finally {
382                 if (announcementsFlag != null) {
383                     cacheResult(announcementsFlag);
384                 }
385 
386                 closeSession(session);
387             }
388         }
389 
390         return announcementsFlag;
391     }
392 
393     public List<AnnouncementsFlag> findByEntryId(long entryId)
394         throws SystemException {
395         Object[] finderArgs = new Object[] { new Long(entryId) };
396 
397         List<AnnouncementsFlag> list = (List<AnnouncementsFlag>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_ENTRYID,
398                 finderArgs, this);
399 
400         if (list == null) {
401             Session session = null;
402 
403             try {
404                 session = openSession();
405 
406                 StringBundler query = new StringBundler(3);
407 
408                 query.append(_SQL_SELECT_ANNOUNCEMENTSFLAG_WHERE);
409 
410                 query.append(_FINDER_COLUMN_ENTRYID_ENTRYID_2);
411 
412                 query.append(AnnouncementsFlagModelImpl.ORDER_BY_JPQL);
413 
414                 String sql = query.toString();
415 
416                 Query q = session.createQuery(sql);
417 
418                 QueryPos qPos = QueryPos.getInstance(q);
419 
420                 qPos.add(entryId);
421 
422                 list = q.list();
423             }
424             catch (Exception e) {
425                 throw processException(e);
426             }
427             finally {
428                 if (list == null) {
429                     list = new ArrayList<AnnouncementsFlag>();
430                 }
431 
432                 cacheResult(list);
433 
434                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_ENTRYID,
435                     finderArgs, list);
436 
437                 closeSession(session);
438             }
439         }
440 
441         return list;
442     }
443 
444     public List<AnnouncementsFlag> findByEntryId(long entryId, int start,
445         int end) throws SystemException {
446         return findByEntryId(entryId, start, end, null);
447     }
448 
449     public List<AnnouncementsFlag> findByEntryId(long entryId, int start,
450         int end, OrderByComparator orderByComparator) throws SystemException {
451         Object[] finderArgs = new Object[] {
452                 new Long(entryId),
453                 
454                 String.valueOf(start), String.valueOf(end),
455                 String.valueOf(orderByComparator)
456             };
457 
458         List<AnnouncementsFlag> list = (List<AnnouncementsFlag>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_ENTRYID,
459                 finderArgs, this);
460 
461         if (list == null) {
462             Session session = null;
463 
464             try {
465                 session = openSession();
466 
467                 StringBundler query = null;
468 
469                 if (orderByComparator != null) {
470                     query = new StringBundler(3 +
471                             (orderByComparator.getOrderByFields().length * 3));
472                 }
473                 else {
474                     query = new StringBundler(3);
475                 }
476 
477                 query.append(_SQL_SELECT_ANNOUNCEMENTSFLAG_WHERE);
478 
479                 query.append(_FINDER_COLUMN_ENTRYID_ENTRYID_2);
480 
481                 if (orderByComparator != null) {
482                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
483                         orderByComparator);
484                 }
485 
486                 else {
487                     query.append(AnnouncementsFlagModelImpl.ORDER_BY_JPQL);
488                 }
489 
490                 String sql = query.toString();
491 
492                 Query q = session.createQuery(sql);
493 
494                 QueryPos qPos = QueryPos.getInstance(q);
495 
496                 qPos.add(entryId);
497 
498                 list = (List<AnnouncementsFlag>)QueryUtil.list(q, getDialect(),
499                         start, end);
500             }
501             catch (Exception e) {
502                 throw processException(e);
503             }
504             finally {
505                 if (list == null) {
506                     list = new ArrayList<AnnouncementsFlag>();
507                 }
508 
509                 cacheResult(list);
510 
511                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_ENTRYID,
512                     finderArgs, list);
513 
514                 closeSession(session);
515             }
516         }
517 
518         return list;
519     }
520 
521     public AnnouncementsFlag findByEntryId_First(long entryId,
522         OrderByComparator orderByComparator)
523         throws NoSuchFlagException, SystemException {
524         List<AnnouncementsFlag> list = findByEntryId(entryId, 0, 1,
525                 orderByComparator);
526 
527         if (list.isEmpty()) {
528             StringBundler msg = new StringBundler(4);
529 
530             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
531 
532             msg.append("entryId=");
533             msg.append(entryId);
534 
535             msg.append(StringPool.CLOSE_CURLY_BRACE);
536 
537             throw new NoSuchFlagException(msg.toString());
538         }
539         else {
540             return list.get(0);
541         }
542     }
543 
544     public AnnouncementsFlag findByEntryId_Last(long entryId,
545         OrderByComparator orderByComparator)
546         throws NoSuchFlagException, SystemException {
547         int count = countByEntryId(entryId);
548 
549         List<AnnouncementsFlag> list = findByEntryId(entryId, count - 1, count,
550                 orderByComparator);
551 
552         if (list.isEmpty()) {
553             StringBundler msg = new StringBundler(4);
554 
555             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
556 
557             msg.append("entryId=");
558             msg.append(entryId);
559 
560             msg.append(StringPool.CLOSE_CURLY_BRACE);
561 
562             throw new NoSuchFlagException(msg.toString());
563         }
564         else {
565             return list.get(0);
566         }
567     }
568 
569     public AnnouncementsFlag[] findByEntryId_PrevAndNext(long flagId,
570         long entryId, OrderByComparator orderByComparator)
571         throws NoSuchFlagException, SystemException {
572         AnnouncementsFlag announcementsFlag = findByPrimaryKey(flagId);
573 
574         int count = countByEntryId(entryId);
575 
576         Session session = null;
577 
578         try {
579             session = openSession();
580 
581             StringBundler query = null;
582 
583             if (orderByComparator != null) {
584                 query = new StringBundler(3 +
585                         (orderByComparator.getOrderByFields().length * 3));
586             }
587             else {
588                 query = new StringBundler(3);
589             }
590 
591             query.append(_SQL_SELECT_ANNOUNCEMENTSFLAG_WHERE);
592 
593             query.append(_FINDER_COLUMN_ENTRYID_ENTRYID_2);
594 
595             if (orderByComparator != null) {
596                 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
597                     orderByComparator);
598             }
599 
600             else {
601                 query.append(AnnouncementsFlagModelImpl.ORDER_BY_JPQL);
602             }
603 
604             String sql = query.toString();
605 
606             Query q = session.createQuery(sql);
607 
608             QueryPos qPos = QueryPos.getInstance(q);
609 
610             qPos.add(entryId);
611 
612             Object[] objArray = QueryUtil.getPrevAndNext(q, count,
613                     orderByComparator, announcementsFlag);
614 
615             AnnouncementsFlag[] array = new AnnouncementsFlagImpl[3];
616 
617             array[0] = (AnnouncementsFlag)objArray[0];
618             array[1] = (AnnouncementsFlag)objArray[1];
619             array[2] = (AnnouncementsFlag)objArray[2];
620 
621             return array;
622         }
623         catch (Exception e) {
624             throw processException(e);
625         }
626         finally {
627             closeSession(session);
628         }
629     }
630 
631     public AnnouncementsFlag findByU_E_V(long userId, long entryId, int value)
632         throws NoSuchFlagException, SystemException {
633         AnnouncementsFlag announcementsFlag = fetchByU_E_V(userId, entryId,
634                 value);
635 
636         if (announcementsFlag == null) {
637             StringBundler msg = new StringBundler(8);
638 
639             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
640 
641             msg.append("userId=");
642             msg.append(userId);
643 
644             msg.append(", entryId=");
645             msg.append(entryId);
646 
647             msg.append(", value=");
648             msg.append(value);
649 
650             msg.append(StringPool.CLOSE_CURLY_BRACE);
651 
652             if (_log.isWarnEnabled()) {
653                 _log.warn(msg.toString());
654             }
655 
656             throw new NoSuchFlagException(msg.toString());
657         }
658 
659         return announcementsFlag;
660     }
661 
662     public AnnouncementsFlag fetchByU_E_V(long userId, long entryId, int value)
663         throws SystemException {
664         return fetchByU_E_V(userId, entryId, value, true);
665     }
666 
667     public AnnouncementsFlag fetchByU_E_V(long userId, long entryId, int value,
668         boolean retrieveFromCache) throws SystemException {
669         Object[] finderArgs = new Object[] {
670                 new Long(userId), new Long(entryId), new Integer(value)
671             };
672 
673         Object result = null;
674 
675         if (retrieveFromCache) {
676             result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_U_E_V,
677                     finderArgs, this);
678         }
679 
680         if (result == null) {
681             Session session = null;
682 
683             try {
684                 session = openSession();
685 
686                 StringBundler query = new StringBundler(5);
687 
688                 query.append(_SQL_SELECT_ANNOUNCEMENTSFLAG_WHERE);
689 
690                 query.append(_FINDER_COLUMN_U_E_V_USERID_2);
691 
692                 query.append(_FINDER_COLUMN_U_E_V_ENTRYID_2);
693 
694                 query.append(_FINDER_COLUMN_U_E_V_VALUE_2);
695 
696                 query.append(AnnouncementsFlagModelImpl.ORDER_BY_JPQL);
697 
698                 String sql = query.toString();
699 
700                 Query q = session.createQuery(sql);
701 
702                 QueryPos qPos = QueryPos.getInstance(q);
703 
704                 qPos.add(userId);
705 
706                 qPos.add(entryId);
707 
708                 qPos.add(value);
709 
710                 List<AnnouncementsFlag> list = q.list();
711 
712                 result = list;
713 
714                 AnnouncementsFlag announcementsFlag = null;
715 
716                 if (list.isEmpty()) {
717                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_U_E_V,
718                         finderArgs, list);
719                 }
720                 else {
721                     announcementsFlag = list.get(0);
722 
723                     cacheResult(announcementsFlag);
724 
725                     if ((announcementsFlag.getUserId() != userId) ||
726                             (announcementsFlag.getEntryId() != entryId) ||
727                             (announcementsFlag.getValue() != value)) {
728                         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_U_E_V,
729                             finderArgs, announcementsFlag);
730                     }
731                 }
732 
733                 return announcementsFlag;
734             }
735             catch (Exception e) {
736                 throw processException(e);
737             }
738             finally {
739                 if (result == null) {
740                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_U_E_V,
741                         finderArgs, new ArrayList<AnnouncementsFlag>());
742                 }
743 
744                 closeSession(session);
745             }
746         }
747         else {
748             if (result instanceof List<?>) {
749                 return null;
750             }
751             else {
752                 return (AnnouncementsFlag)result;
753             }
754         }
755     }
756 
757     public List<AnnouncementsFlag> findAll() throws SystemException {
758         return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
759     }
760 
761     public List<AnnouncementsFlag> findAll(int start, int end)
762         throws SystemException {
763         return findAll(start, end, null);
764     }
765 
766     public List<AnnouncementsFlag> findAll(int start, int end,
767         OrderByComparator orderByComparator) throws SystemException {
768         Object[] finderArgs = new Object[] {
769                 String.valueOf(start), String.valueOf(end),
770                 String.valueOf(orderByComparator)
771             };
772 
773         List<AnnouncementsFlag> list = (List<AnnouncementsFlag>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
774                 finderArgs, this);
775 
776         if (list == null) {
777             Session session = null;
778 
779             try {
780                 session = openSession();
781 
782                 StringBundler query = null;
783                 String sql = null;
784 
785                 if (orderByComparator != null) {
786                     query = new StringBundler(2 +
787                             (orderByComparator.getOrderByFields().length * 3));
788 
789                     query.append(_SQL_SELECT_ANNOUNCEMENTSFLAG);
790 
791                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
792                         orderByComparator);
793 
794                     sql = query.toString();
795                 }
796 
797                 else {
798                     sql = _SQL_SELECT_ANNOUNCEMENTSFLAG.concat(AnnouncementsFlagModelImpl.ORDER_BY_JPQL);
799                 }
800 
801                 Query q = session.createQuery(sql);
802 
803                 if (orderByComparator == null) {
804                     list = (List<AnnouncementsFlag>)QueryUtil.list(q,
805                             getDialect(), start, end, false);
806 
807                     Collections.sort(list);
808                 }
809                 else {
810                     list = (List<AnnouncementsFlag>)QueryUtil.list(q,
811                             getDialect(), start, end);
812                 }
813             }
814             catch (Exception e) {
815                 throw processException(e);
816             }
817             finally {
818                 if (list == null) {
819                     list = new ArrayList<AnnouncementsFlag>();
820                 }
821 
822                 cacheResult(list);
823 
824                 FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
825 
826                 closeSession(session);
827             }
828         }
829 
830         return list;
831     }
832 
833     public void removeByEntryId(long entryId) throws SystemException {
834         for (AnnouncementsFlag announcementsFlag : findByEntryId(entryId)) {
835             remove(announcementsFlag);
836         }
837     }
838 
839     public void removeByU_E_V(long userId, long entryId, int value)
840         throws NoSuchFlagException, SystemException {
841         AnnouncementsFlag announcementsFlag = findByU_E_V(userId, entryId, value);
842 
843         remove(announcementsFlag);
844     }
845 
846     public void removeAll() throws SystemException {
847         for (AnnouncementsFlag announcementsFlag : findAll()) {
848             remove(announcementsFlag);
849         }
850     }
851 
852     public int countByEntryId(long entryId) throws SystemException {
853         Object[] finderArgs = new Object[] { new Long(entryId) };
854 
855         Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_ENTRYID,
856                 finderArgs, this);
857 
858         if (count == null) {
859             Session session = null;
860 
861             try {
862                 session = openSession();
863 
864                 StringBundler query = new StringBundler(2);
865 
866                 query.append(_SQL_COUNT_ANNOUNCEMENTSFLAG_WHERE);
867 
868                 query.append(_FINDER_COLUMN_ENTRYID_ENTRYID_2);
869 
870                 String sql = query.toString();
871 
872                 Query q = session.createQuery(sql);
873 
874                 QueryPos qPos = QueryPos.getInstance(q);
875 
876                 qPos.add(entryId);
877 
878                 count = (Long)q.uniqueResult();
879             }
880             catch (Exception e) {
881                 throw processException(e);
882             }
883             finally {
884                 if (count == null) {
885                     count = Long.valueOf(0);
886                 }
887 
888                 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_ENTRYID,
889                     finderArgs, count);
890 
891                 closeSession(session);
892             }
893         }
894 
895         return count.intValue();
896     }
897 
898     public int countByU_E_V(long userId, long entryId, int value)
899         throws SystemException {
900         Object[] finderArgs = new Object[] {
901                 new Long(userId), new Long(entryId), new Integer(value)
902             };
903 
904         Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_U_E_V,
905                 finderArgs, this);
906 
907         if (count == null) {
908             Session session = null;
909 
910             try {
911                 session = openSession();
912 
913                 StringBundler query = new StringBundler(4);
914 
915                 query.append(_SQL_COUNT_ANNOUNCEMENTSFLAG_WHERE);
916 
917                 query.append(_FINDER_COLUMN_U_E_V_USERID_2);
918 
919                 query.append(_FINDER_COLUMN_U_E_V_ENTRYID_2);
920 
921                 query.append(_FINDER_COLUMN_U_E_V_VALUE_2);
922 
923                 String sql = query.toString();
924 
925                 Query q = session.createQuery(sql);
926 
927                 QueryPos qPos = QueryPos.getInstance(q);
928 
929                 qPos.add(userId);
930 
931                 qPos.add(entryId);
932 
933                 qPos.add(value);
934 
935                 count = (Long)q.uniqueResult();
936             }
937             catch (Exception e) {
938                 throw processException(e);
939             }
940             finally {
941                 if (count == null) {
942                     count = Long.valueOf(0);
943                 }
944 
945                 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_U_E_V,
946                     finderArgs, count);
947 
948                 closeSession(session);
949             }
950         }
951 
952         return count.intValue();
953     }
954 
955     public int countAll() throws SystemException {
956         Object[] finderArgs = new Object[0];
957 
958         Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
959                 finderArgs, this);
960 
961         if (count == null) {
962             Session session = null;
963 
964             try {
965                 session = openSession();
966 
967                 Query q = session.createQuery(_SQL_COUNT_ANNOUNCEMENTSFLAG);
968 
969                 count = (Long)q.uniqueResult();
970             }
971             catch (Exception e) {
972                 throw processException(e);
973             }
974             finally {
975                 if (count == null) {
976                     count = Long.valueOf(0);
977                 }
978 
979                 FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
980                     count);
981 
982                 closeSession(session);
983             }
984         }
985 
986         return count.intValue();
987     }
988 
989     public void afterPropertiesSet() {
990         String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
991                     com.liferay.portal.util.PropsUtil.get(
992                         "value.object.listener.com.liferay.portlet.announcements.model.AnnouncementsFlag")));
993 
994         if (listenerClassNames.length > 0) {
995             try {
996                 List<ModelListener<AnnouncementsFlag>> listenersList = new ArrayList<ModelListener<AnnouncementsFlag>>();
997 
998                 for (String listenerClassName : listenerClassNames) {
999                     listenersList.add((ModelListener<AnnouncementsFlag>)Class.forName(
1000                            listenerClassName).newInstance());
1001                }
1002
1003                listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
1004            }
1005            catch (Exception e) {
1006                _log.error(e);
1007            }
1008        }
1009    }
1010
1011    @BeanReference(type = AnnouncementsDeliveryPersistence.class)
1012    protected AnnouncementsDeliveryPersistence announcementsDeliveryPersistence;
1013    @BeanReference(type = AnnouncementsEntryPersistence.class)
1014    protected AnnouncementsEntryPersistence announcementsEntryPersistence;
1015    @BeanReference(type = AnnouncementsFlagPersistence.class)
1016    protected AnnouncementsFlagPersistence announcementsFlagPersistence;
1017    @BeanReference(type = ResourcePersistence.class)
1018    protected ResourcePersistence resourcePersistence;
1019    @BeanReference(type = UserPersistence.class)
1020    protected UserPersistence userPersistence;
1021    private static final String _SQL_SELECT_ANNOUNCEMENTSFLAG = "SELECT announcementsFlag FROM AnnouncementsFlag announcementsFlag";
1022    private static final String _SQL_SELECT_ANNOUNCEMENTSFLAG_WHERE = "SELECT announcementsFlag FROM AnnouncementsFlag announcementsFlag WHERE ";
1023    private static final String _SQL_COUNT_ANNOUNCEMENTSFLAG = "SELECT COUNT(announcementsFlag) FROM AnnouncementsFlag announcementsFlag";
1024    private static final String _SQL_COUNT_ANNOUNCEMENTSFLAG_WHERE = "SELECT COUNT(announcementsFlag) FROM AnnouncementsFlag announcementsFlag WHERE ";
1025    private static final String _FINDER_COLUMN_ENTRYID_ENTRYID_2 = "announcementsFlag.entryId = ?";
1026    private static final String _FINDER_COLUMN_U_E_V_USERID_2 = "announcementsFlag.userId = ? AND ";
1027    private static final String _FINDER_COLUMN_U_E_V_ENTRYID_2 = "announcementsFlag.entryId = ? AND ";
1028    private static final String _FINDER_COLUMN_U_E_V_VALUE_2 = "announcementsFlag.value = ?";
1029    private static final String _ORDER_BY_ENTITY_ALIAS = "announcementsFlag.";
1030    private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No AnnouncementsFlag exists with the primary key ";
1031    private static final String _NO_SUCH_ENTITY_WITH_KEY = "No AnnouncementsFlag exists with the key {";
1032    private static Log _log = LogFactoryUtil.getLog(AnnouncementsFlagPersistenceImpl.class);
1033}