1   /**
2    * Copyright (c) 2000-2009 Liferay, Inc. All rights reserved.
3    *
4    * Permission is hereby granted, free of charge, to any person obtaining a copy
5    * of this software and associated documentation files (the "Software"), to deal
6    * in the Software without restriction, including without limitation the rights
7    * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8    * copies of the Software, and to permit persons to whom the Software is
9    * furnished to do so, subject to the following conditions:
10   *
11   * The above copyright notice and this permission notice shall be included in
12   * all copies or substantial portions of the Software.
13   *
14   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20   * SOFTWARE.
21   */
22  
23  package com.liferay.portlet.messageboards.service.persistence;
24  
25  import com.liferay.portal.SystemException;
26  import com.liferay.portal.kernel.annotation.BeanReference;
27  import com.liferay.portal.kernel.cache.CacheRegistry;
28  import com.liferay.portal.kernel.dao.orm.DynamicQuery;
29  import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
30  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
31  import com.liferay.portal.kernel.dao.orm.FinderPath;
32  import com.liferay.portal.kernel.dao.orm.Query;
33  import com.liferay.portal.kernel.dao.orm.QueryPos;
34  import com.liferay.portal.kernel.dao.orm.QueryUtil;
35  import com.liferay.portal.kernel.dao.orm.Session;
36  import com.liferay.portal.kernel.log.Log;
37  import com.liferay.portal.kernel.log.LogFactoryUtil;
38  import com.liferay.portal.kernel.util.GetterUtil;
39  import com.liferay.portal.kernel.util.OrderByComparator;
40  import com.liferay.portal.kernel.util.StringPool;
41  import com.liferay.portal.kernel.util.StringUtil;
42  import com.liferay.portal.model.ModelListener;
43  import com.liferay.portal.service.persistence.BatchSessionUtil;
44  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
45  
46  import com.liferay.portlet.messageboards.NoSuchMessageFlagException;
47  import com.liferay.portlet.messageboards.model.MBMessageFlag;
48  import com.liferay.portlet.messageboards.model.impl.MBMessageFlagImpl;
49  import com.liferay.portlet.messageboards.model.impl.MBMessageFlagModelImpl;
50  
51  import java.util.ArrayList;
52  import java.util.Collections;
53  import java.util.List;
54  
55  /**
56   * <a href="MBMessageFlagPersistenceImpl.java.html"><b><i>View Source</i></b></a>
57   *
58   * @author Brian Wing Shun Chan
59   *
60   */
61  public class MBMessageFlagPersistenceImpl extends BasePersistenceImpl
62      implements MBMessageFlagPersistence {
63      public static final String FINDER_CLASS_NAME_ENTITY = MBMessageFlagImpl.class.getName();
64      public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
65          ".List";
66      public static final FinderPath FINDER_PATH_FIND_BY_USERID = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
67              MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
68              FINDER_CLASS_NAME_LIST, "findByUserId",
69              new String[] { Long.class.getName() });
70      public static final FinderPath FINDER_PATH_FIND_BY_OBC_USERID = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
71              MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
72              FINDER_CLASS_NAME_LIST, "findByUserId",
73              new String[] {
74                  Long.class.getName(),
75                  
76              "java.lang.Integer", "java.lang.Integer",
77                  "com.liferay.portal.kernel.util.OrderByComparator"
78              });
79      public static final FinderPath FINDER_PATH_COUNT_BY_USERID = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
80              MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
81              FINDER_CLASS_NAME_LIST, "countByUserId",
82              new String[] { Long.class.getName() });
83      public static final FinderPath FINDER_PATH_FIND_BY_THREADID = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
84              MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
85              FINDER_CLASS_NAME_LIST, "findByThreadId",
86              new String[] { Long.class.getName() });
87      public static final FinderPath FINDER_PATH_FIND_BY_OBC_THREADID = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
88              MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
89              FINDER_CLASS_NAME_LIST, "findByThreadId",
90              new String[] {
91                  Long.class.getName(),
92                  
93              "java.lang.Integer", "java.lang.Integer",
94                  "com.liferay.portal.kernel.util.OrderByComparator"
95              });
96      public static final FinderPath FINDER_PATH_COUNT_BY_THREADID = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
97              MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
98              FINDER_CLASS_NAME_LIST, "countByThreadId",
99              new String[] { Long.class.getName() });
100     public static final FinderPath FINDER_PATH_FIND_BY_MESSAGEID = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
101             MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
102             FINDER_CLASS_NAME_LIST, "findByMessageId",
103             new String[] { Long.class.getName() });
104     public static final FinderPath FINDER_PATH_FIND_BY_OBC_MESSAGEID = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
105             MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
106             FINDER_CLASS_NAME_LIST, "findByMessageId",
107             new String[] {
108                 Long.class.getName(),
109                 
110             "java.lang.Integer", "java.lang.Integer",
111                 "com.liferay.portal.kernel.util.OrderByComparator"
112             });
113     public static final FinderPath FINDER_PATH_COUNT_BY_MESSAGEID = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
114             MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
115             FINDER_CLASS_NAME_LIST, "countByMessageId",
116             new String[] { Long.class.getName() });
117     public static final FinderPath FINDER_PATH_FIND_BY_T_F = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
118             MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
119             FINDER_CLASS_NAME_LIST, "findByT_F",
120             new String[] { Long.class.getName(), Integer.class.getName() });
121     public static final FinderPath FINDER_PATH_FIND_BY_OBC_T_F = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
122             MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
123             FINDER_CLASS_NAME_LIST, "findByT_F",
124             new String[] {
125                 Long.class.getName(), Integer.class.getName(),
126                 
127             "java.lang.Integer", "java.lang.Integer",
128                 "com.liferay.portal.kernel.util.OrderByComparator"
129             });
130     public static final FinderPath FINDER_PATH_COUNT_BY_T_F = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
131             MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
132             FINDER_CLASS_NAME_LIST, "countByT_F",
133             new String[] { Long.class.getName(), Integer.class.getName() });
134     public static final FinderPath FINDER_PATH_FIND_BY_M_F = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
135             MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
136             FINDER_CLASS_NAME_LIST, "findByM_F",
137             new String[] { Long.class.getName(), Integer.class.getName() });
138     public static final FinderPath FINDER_PATH_FIND_BY_OBC_M_F = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
139             MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
140             FINDER_CLASS_NAME_LIST, "findByM_F",
141             new String[] {
142                 Long.class.getName(), Integer.class.getName(),
143                 
144             "java.lang.Integer", "java.lang.Integer",
145                 "com.liferay.portal.kernel.util.OrderByComparator"
146             });
147     public static final FinderPath FINDER_PATH_COUNT_BY_M_F = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
148             MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
149             FINDER_CLASS_NAME_LIST, "countByM_F",
150             new String[] { Long.class.getName(), Integer.class.getName() });
151     public static final FinderPath FINDER_PATH_FIND_BY_U_T_F = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
152             MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
153             FINDER_CLASS_NAME_LIST, "findByU_T_F",
154             new String[] {
155                 Long.class.getName(), Long.class.getName(),
156                 Integer.class.getName()
157             });
158     public static final FinderPath FINDER_PATH_FIND_BY_OBC_U_T_F = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
159             MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
160             FINDER_CLASS_NAME_LIST, "findByU_T_F",
161             new String[] {
162                 Long.class.getName(), Long.class.getName(),
163                 Integer.class.getName(),
164                 
165             "java.lang.Integer", "java.lang.Integer",
166                 "com.liferay.portal.kernel.util.OrderByComparator"
167             });
168     public static final FinderPath FINDER_PATH_COUNT_BY_U_T_F = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
169             MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
170             FINDER_CLASS_NAME_LIST, "countByU_T_F",
171             new String[] {
172                 Long.class.getName(), Long.class.getName(),
173                 Integer.class.getName()
174             });
175     public static final FinderPath FINDER_PATH_FETCH_BY_U_M_F = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
176             MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
177             FINDER_CLASS_NAME_ENTITY, "fetchByU_M_F",
178             new String[] {
179                 Long.class.getName(), Long.class.getName(),
180                 Integer.class.getName()
181             });
182     public static final FinderPath FINDER_PATH_COUNT_BY_U_M_F = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
183             MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
184             FINDER_CLASS_NAME_LIST, "countByU_M_F",
185             new String[] {
186                 Long.class.getName(), Long.class.getName(),
187                 Integer.class.getName()
188             });
189     public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
190             MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
191             FINDER_CLASS_NAME_LIST, "findAll", new String[0]);
192     public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
193             MBMessageFlagModelImpl.FINDER_CACHE_ENABLED,
194             FINDER_CLASS_NAME_LIST, "countAll", new String[0]);
195 
196     public void cacheResult(MBMessageFlag mbMessageFlag) {
197         EntityCacheUtil.putResult(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
198             MBMessageFlagImpl.class, mbMessageFlag.getPrimaryKey(),
199             mbMessageFlag);
200 
201         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_U_M_F,
202             new Object[] {
203                 new Long(mbMessageFlag.getUserId()),
204                 new Long(mbMessageFlag.getMessageId()),
205                 new Integer(mbMessageFlag.getFlag())
206             }, mbMessageFlag);
207     }
208 
209     public void cacheResult(List<MBMessageFlag> mbMessageFlags) {
210         for (MBMessageFlag mbMessageFlag : mbMessageFlags) {
211             if (EntityCacheUtil.getResult(
212                         MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
213                         MBMessageFlagImpl.class, mbMessageFlag.getPrimaryKey(),
214                         this) == null) {
215                 cacheResult(mbMessageFlag);
216             }
217         }
218     }
219 
220     public void clearCache() {
221         CacheRegistry.clear(MBMessageFlagImpl.class.getName());
222         EntityCacheUtil.clearCache(MBMessageFlagImpl.class.getName());
223         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
224         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
225     }
226 
227     public MBMessageFlag create(long messageFlagId) {
228         MBMessageFlag mbMessageFlag = new MBMessageFlagImpl();
229 
230         mbMessageFlag.setNew(true);
231         mbMessageFlag.setPrimaryKey(messageFlagId);
232 
233         return mbMessageFlag;
234     }
235 
236     public MBMessageFlag remove(long messageFlagId)
237         throws NoSuchMessageFlagException, SystemException {
238         Session session = null;
239 
240         try {
241             session = openSession();
242 
243             MBMessageFlag mbMessageFlag = (MBMessageFlag)session.get(MBMessageFlagImpl.class,
244                     new Long(messageFlagId));
245 
246             if (mbMessageFlag == null) {
247                 if (_log.isWarnEnabled()) {
248                     _log.warn("No MBMessageFlag exists with the primary key " +
249                         messageFlagId);
250                 }
251 
252                 throw new NoSuchMessageFlagException(
253                     "No MBMessageFlag exists with the primary key " +
254                     messageFlagId);
255             }
256 
257             return remove(mbMessageFlag);
258         }
259         catch (NoSuchMessageFlagException nsee) {
260             throw nsee;
261         }
262         catch (Exception e) {
263             throw processException(e);
264         }
265         finally {
266             closeSession(session);
267         }
268     }
269 
270     public MBMessageFlag remove(MBMessageFlag mbMessageFlag)
271         throws SystemException {
272         for (ModelListener<MBMessageFlag> listener : listeners) {
273             listener.onBeforeRemove(mbMessageFlag);
274         }
275 
276         mbMessageFlag = removeImpl(mbMessageFlag);
277 
278         for (ModelListener<MBMessageFlag> listener : listeners) {
279             listener.onAfterRemove(mbMessageFlag);
280         }
281 
282         return mbMessageFlag;
283     }
284 
285     protected MBMessageFlag removeImpl(MBMessageFlag mbMessageFlag)
286         throws SystemException {
287         Session session = null;
288 
289         try {
290             session = openSession();
291 
292             if (mbMessageFlag.isCachedModel() || BatchSessionUtil.isEnabled()) {
293                 Object staleObject = session.get(MBMessageFlagImpl.class,
294                         mbMessageFlag.getPrimaryKeyObj());
295 
296                 if (staleObject != null) {
297                     session.evict(staleObject);
298                 }
299             }
300 
301             session.delete(mbMessageFlag);
302 
303             session.flush();
304         }
305         catch (Exception e) {
306             throw processException(e);
307         }
308         finally {
309             closeSession(session);
310         }
311 
312         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
313 
314         MBMessageFlagModelImpl mbMessageFlagModelImpl = (MBMessageFlagModelImpl)mbMessageFlag;
315 
316         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_U_M_F,
317             new Object[] {
318                 new Long(mbMessageFlagModelImpl.getOriginalUserId()),
319                 new Long(mbMessageFlagModelImpl.getOriginalMessageId()),
320                 new Integer(mbMessageFlagModelImpl.getOriginalFlag())
321             });
322 
323         EntityCacheUtil.removeResult(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
324             MBMessageFlagImpl.class, mbMessageFlag.getPrimaryKey());
325 
326         return mbMessageFlag;
327     }
328 
329     /**
330      * @deprecated Use <code>update(MBMessageFlag mbMessageFlag, boolean merge)</code>.
331      */
332     public MBMessageFlag update(MBMessageFlag mbMessageFlag)
333         throws SystemException {
334         if (_log.isWarnEnabled()) {
335             _log.warn(
336                 "Using the deprecated update(MBMessageFlag mbMessageFlag) method. Use update(MBMessageFlag mbMessageFlag, boolean merge) instead.");
337         }
338 
339         return update(mbMessageFlag, false);
340     }
341 
342     /**
343      * Add, update, or merge, the entity. This method also calls the model
344      * listeners to trigger the proper events associated with adding, deleting,
345      * or updating an entity.
346      *
347      * @param        mbMessageFlag the entity to add, update, or merge
348      * @param        merge boolean value for whether to merge the entity. The
349      *                default value is false. Setting merge to true is more
350      *                expensive and should only be true when mbMessageFlag is
351      *                transient. See LEP-5473 for a detailed discussion of this
352      *                method.
353      * @return        true if the portlet can be displayed via Ajax
354      */
355     public MBMessageFlag update(MBMessageFlag mbMessageFlag, boolean merge)
356         throws SystemException {
357         boolean isNew = mbMessageFlag.isNew();
358 
359         for (ModelListener<MBMessageFlag> listener : listeners) {
360             if (isNew) {
361                 listener.onBeforeCreate(mbMessageFlag);
362             }
363             else {
364                 listener.onBeforeUpdate(mbMessageFlag);
365             }
366         }
367 
368         mbMessageFlag = updateImpl(mbMessageFlag, merge);
369 
370         for (ModelListener<MBMessageFlag> listener : listeners) {
371             if (isNew) {
372                 listener.onAfterCreate(mbMessageFlag);
373             }
374             else {
375                 listener.onAfterUpdate(mbMessageFlag);
376             }
377         }
378 
379         return mbMessageFlag;
380     }
381 
382     public MBMessageFlag updateImpl(
383         com.liferay.portlet.messageboards.model.MBMessageFlag mbMessageFlag,
384         boolean merge) throws SystemException {
385         boolean isNew = mbMessageFlag.isNew();
386 
387         MBMessageFlagModelImpl mbMessageFlagModelImpl = (MBMessageFlagModelImpl)mbMessageFlag;
388 
389         Session session = null;
390 
391         try {
392             session = openSession();
393 
394             BatchSessionUtil.update(session, mbMessageFlag, merge);
395 
396             mbMessageFlag.setNew(false);
397         }
398         catch (Exception e) {
399             throw processException(e);
400         }
401         finally {
402             closeSession(session);
403         }
404 
405         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
406 
407         EntityCacheUtil.putResult(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
408             MBMessageFlagImpl.class, mbMessageFlag.getPrimaryKey(),
409             mbMessageFlag);
410 
411         if (!isNew &&
412                 ((mbMessageFlag.getUserId() != mbMessageFlagModelImpl.getOriginalUserId()) ||
413                 (mbMessageFlag.getMessageId() != mbMessageFlagModelImpl.getOriginalMessageId()) ||
414                 (mbMessageFlag.getFlag() != mbMessageFlagModelImpl.getOriginalFlag()))) {
415             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_U_M_F,
416                 new Object[] {
417                     new Long(mbMessageFlagModelImpl.getOriginalUserId()),
418                     new Long(mbMessageFlagModelImpl.getOriginalMessageId()),
419                     new Integer(mbMessageFlagModelImpl.getOriginalFlag())
420                 });
421         }
422 
423         if (isNew ||
424                 ((mbMessageFlag.getUserId() != mbMessageFlagModelImpl.getOriginalUserId()) ||
425                 (mbMessageFlag.getMessageId() != mbMessageFlagModelImpl.getOriginalMessageId()) ||
426                 (mbMessageFlag.getFlag() != mbMessageFlagModelImpl.getOriginalFlag()))) {
427             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_U_M_F,
428                 new Object[] {
429                     new Long(mbMessageFlag.getUserId()),
430                     new Long(mbMessageFlag.getMessageId()),
431                     new Integer(mbMessageFlag.getFlag())
432                 }, mbMessageFlag);
433         }
434 
435         return mbMessageFlag;
436     }
437 
438     public MBMessageFlag findByPrimaryKey(long messageFlagId)
439         throws NoSuchMessageFlagException, SystemException {
440         MBMessageFlag mbMessageFlag = fetchByPrimaryKey(messageFlagId);
441 
442         if (mbMessageFlag == null) {
443             if (_log.isWarnEnabled()) {
444                 _log.warn("No MBMessageFlag exists with the primary key " +
445                     messageFlagId);
446             }
447 
448             throw new NoSuchMessageFlagException(
449                 "No MBMessageFlag exists with the primary key " +
450                 messageFlagId);
451         }
452 
453         return mbMessageFlag;
454     }
455 
456     public MBMessageFlag fetchByPrimaryKey(long messageFlagId)
457         throws SystemException {
458         MBMessageFlag mbMessageFlag = (MBMessageFlag)EntityCacheUtil.getResult(MBMessageFlagModelImpl.ENTITY_CACHE_ENABLED,
459                 MBMessageFlagImpl.class, messageFlagId, this);
460 
461         if (mbMessageFlag == null) {
462             Session session = null;
463 
464             try {
465                 session = openSession();
466 
467                 mbMessageFlag = (MBMessageFlag)session.get(MBMessageFlagImpl.class,
468                         new Long(messageFlagId));
469             }
470             catch (Exception e) {
471                 throw processException(e);
472             }
473             finally {
474                 if (mbMessageFlag != null) {
475                     cacheResult(mbMessageFlag);
476                 }
477 
478                 closeSession(session);
479             }
480         }
481 
482         return mbMessageFlag;
483     }
484 
485     public List<MBMessageFlag> findByUserId(long userId)
486         throws SystemException {
487         Object[] finderArgs = new Object[] { new Long(userId) };
488 
489         List<MBMessageFlag> list = (List<MBMessageFlag>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_USERID,
490                 finderArgs, this);
491 
492         if (list == null) {
493             Session session = null;
494 
495             try {
496                 session = openSession();
497 
498                 StringBuilder query = new StringBuilder();
499 
500                 query.append(
501                     "SELECT mbMessageFlag FROM MBMessageFlag mbMessageFlag WHERE ");
502 
503                 query.append("mbMessageFlag.userId = ?");
504 
505                 query.append(" ");
506 
507                 Query q = session.createQuery(query.toString());
508 
509                 QueryPos qPos = QueryPos.getInstance(q);
510 
511                 qPos.add(userId);
512 
513                 list = q.list();
514             }
515             catch (Exception e) {
516                 throw processException(e);
517             }
518             finally {
519                 if (list == null) {
520                     list = new ArrayList<MBMessageFlag>();
521                 }
522 
523                 cacheResult(list);
524 
525                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_USERID,
526                     finderArgs, list);
527 
528                 closeSession(session);
529             }
530         }
531 
532         return list;
533     }
534 
535     public List<MBMessageFlag> findByUserId(long userId, int start, int end)
536         throws SystemException {
537         return findByUserId(userId, start, end, null);
538     }
539 
540     public List<MBMessageFlag> findByUserId(long userId, int start, int end,
541         OrderByComparator obc) throws SystemException {
542         Object[] finderArgs = new Object[] {
543                 new Long(userId),
544                 
545                 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
546             };
547 
548         List<MBMessageFlag> list = (List<MBMessageFlag>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_USERID,
549                 finderArgs, this);
550 
551         if (list == null) {
552             Session session = null;
553 
554             try {
555                 session = openSession();
556 
557                 StringBuilder query = new StringBuilder();
558 
559                 query.append(
560                     "SELECT mbMessageFlag FROM MBMessageFlag mbMessageFlag WHERE ");
561 
562                 query.append("mbMessageFlag.userId = ?");
563 
564                 query.append(" ");
565 
566                 if (obc != null) {
567                     query.append("ORDER BY ");
568 
569                     String[] orderByFields = obc.getOrderByFields();
570 
571                     for (int i = 0; i < orderByFields.length; i++) {
572                         query.append("mbMessageFlag.");
573                         query.append(orderByFields[i]);
574 
575                         if (obc.isAscending()) {
576                             query.append(" ASC");
577                         }
578                         else {
579                             query.append(" DESC");
580                         }
581 
582                         if ((i + 1) < orderByFields.length) {
583                             query.append(", ");
584                         }
585                     }
586                 }
587 
588                 Query q = session.createQuery(query.toString());
589 
590                 QueryPos qPos = QueryPos.getInstance(q);
591 
592                 qPos.add(userId);
593 
594                 list = (List<MBMessageFlag>)QueryUtil.list(q, getDialect(),
595                         start, end);
596             }
597             catch (Exception e) {
598                 throw processException(e);
599             }
600             finally {
601                 if (list == null) {
602                     list = new ArrayList<MBMessageFlag>();
603                 }
604 
605                 cacheResult(list);
606 
607                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_USERID,
608                     finderArgs, list);
609 
610                 closeSession(session);
611             }
612         }
613 
614         return list;
615     }
616 
617     public MBMessageFlag findByUserId_First(long userId, OrderByComparator obc)
618         throws NoSuchMessageFlagException, SystemException {
619         List<MBMessageFlag> list = findByUserId(userId, 0, 1, obc);
620 
621         if (list.isEmpty()) {
622             StringBuilder msg = new StringBuilder();
623 
624             msg.append("No MBMessageFlag exists with the key {");
625 
626             msg.append("userId=" + userId);
627 
628             msg.append(StringPool.CLOSE_CURLY_BRACE);
629 
630             throw new NoSuchMessageFlagException(msg.toString());
631         }
632         else {
633             return list.get(0);
634         }
635     }
636 
637     public MBMessageFlag findByUserId_Last(long userId, OrderByComparator obc)
638         throws NoSuchMessageFlagException, SystemException {
639         int count = countByUserId(userId);
640 
641         List<MBMessageFlag> list = findByUserId(userId, count - 1, count, obc);
642 
643         if (list.isEmpty()) {
644             StringBuilder msg = new StringBuilder();
645 
646             msg.append("No MBMessageFlag exists with the key {");
647 
648             msg.append("userId=" + userId);
649 
650             msg.append(StringPool.CLOSE_CURLY_BRACE);
651 
652             throw new NoSuchMessageFlagException(msg.toString());
653         }
654         else {
655             return list.get(0);
656         }
657     }
658 
659     public MBMessageFlag[] findByUserId_PrevAndNext(long messageFlagId,
660         long userId, OrderByComparator obc)
661         throws NoSuchMessageFlagException, SystemException {
662         MBMessageFlag mbMessageFlag = findByPrimaryKey(messageFlagId);
663 
664         int count = countByUserId(userId);
665 
666         Session session = null;
667 
668         try {
669             session = openSession();
670 
671             StringBuilder query = new StringBuilder();
672 
673             query.append(
674                 "SELECT mbMessageFlag FROM MBMessageFlag mbMessageFlag WHERE ");
675 
676             query.append("mbMessageFlag.userId = ?");
677 
678             query.append(" ");
679 
680             if (obc != null) {
681                 query.append("ORDER BY ");
682 
683                 String[] orderByFields = obc.getOrderByFields();
684 
685                 for (int i = 0; i < orderByFields.length; i++) {
686                     query.append("mbMessageFlag.");
687                     query.append(orderByFields[i]);
688 
689                     if (obc.isAscending()) {
690                         query.append(" ASC");
691                     }
692                     else {
693                         query.append(" DESC");
694                     }
695 
696                     if ((i + 1) < orderByFields.length) {
697                         query.append(", ");
698                     }
699                 }
700             }
701 
702             Query q = session.createQuery(query.toString());
703 
704             QueryPos qPos = QueryPos.getInstance(q);
705 
706             qPos.add(userId);
707 
708             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
709                     mbMessageFlag);
710 
711             MBMessageFlag[] array = new MBMessageFlagImpl[3];
712 
713             array[0] = (MBMessageFlag)objArray[0];
714             array[1] = (MBMessageFlag)objArray[1];
715             array[2] = (MBMessageFlag)objArray[2];
716 
717             return array;
718         }
719         catch (Exception e) {
720             throw processException(e);
721         }
722         finally {
723             closeSession(session);
724         }
725     }
726 
727     public List<MBMessageFlag> findByThreadId(long threadId)
728         throws SystemException {
729         Object[] finderArgs = new Object[] { new Long(threadId) };
730 
731         List<MBMessageFlag> list = (List<MBMessageFlag>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_THREADID,
732                 finderArgs, this);
733 
734         if (list == null) {
735             Session session = null;
736 
737             try {
738                 session = openSession();
739 
740                 StringBuilder query = new StringBuilder();
741 
742                 query.append(
743                     "SELECT mbMessageFlag FROM MBMessageFlag mbMessageFlag WHERE ");
744 
745                 query.append("mbMessageFlag.threadId = ?");
746 
747                 query.append(" ");
748 
749                 Query q = session.createQuery(query.toString());
750 
751                 QueryPos qPos = QueryPos.getInstance(q);
752 
753                 qPos.add(threadId);
754 
755                 list = q.list();
756             }
757             catch (Exception e) {
758                 throw processException(e);
759             }
760             finally {
761                 if (list == null) {
762                     list = new ArrayList<MBMessageFlag>();
763                 }
764 
765                 cacheResult(list);
766 
767                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_THREADID,
768                     finderArgs, list);
769 
770                 closeSession(session);
771             }
772         }
773 
774         return list;
775     }
776 
777     public List<MBMessageFlag> findByThreadId(long threadId, int start, int end)
778         throws SystemException {
779         return findByThreadId(threadId, start, end, null);
780     }
781 
782     public List<MBMessageFlag> findByThreadId(long threadId, int start,
783         int end, OrderByComparator obc) throws SystemException {
784         Object[] finderArgs = new Object[] {
785                 new Long(threadId),
786                 
787                 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
788             };
789 
790         List<MBMessageFlag> list = (List<MBMessageFlag>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_THREADID,
791                 finderArgs, this);
792 
793         if (list == null) {
794             Session session = null;
795 
796             try {
797                 session = openSession();
798 
799                 StringBuilder query = new StringBuilder();
800 
801                 query.append(
802                     "SELECT mbMessageFlag FROM MBMessageFlag mbMessageFlag WHERE ");
803 
804                 query.append("mbMessageFlag.threadId = ?");
805 
806                 query.append(" ");
807 
808                 if (obc != null) {
809                     query.append("ORDER BY ");
810 
811                     String[] orderByFields = obc.getOrderByFields();
812 
813                     for (int i = 0; i < orderByFields.length; i++) {
814                         query.append("mbMessageFlag.");
815                         query.append(orderByFields[i]);
816 
817                         if (obc.isAscending()) {
818                             query.append(" ASC");
819                         }
820                         else {
821                             query.append(" DESC");
822                         }
823 
824                         if ((i + 1) < orderByFields.length) {
825                             query.append(", ");
826                         }
827                     }
828                 }
829 
830                 Query q = session.createQuery(query.toString());
831 
832                 QueryPos qPos = QueryPos.getInstance(q);
833 
834                 qPos.add(threadId);
835 
836                 list = (List<MBMessageFlag>)QueryUtil.list(q, getDialect(),
837                         start, end);
838             }
839             catch (Exception e) {
840                 throw processException(e);
841             }
842             finally {
843                 if (list == null) {
844                     list = new ArrayList<MBMessageFlag>();
845                 }
846 
847                 cacheResult(list);
848 
849                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_THREADID,
850                     finderArgs, list);
851 
852                 closeSession(session);
853             }
854         }
855 
856         return list;
857     }
858 
859     public MBMessageFlag findByThreadId_First(long threadId,
860         OrderByComparator obc)
861         throws NoSuchMessageFlagException, SystemException {
862         List<MBMessageFlag> list = findByThreadId(threadId, 0, 1, obc);
863 
864         if (list.isEmpty()) {
865             StringBuilder msg = new StringBuilder();
866 
867             msg.append("No MBMessageFlag exists with the key {");
868 
869             msg.append("threadId=" + threadId);
870 
871             msg.append(StringPool.CLOSE_CURLY_BRACE);
872 
873             throw new NoSuchMessageFlagException(msg.toString());
874         }
875         else {
876             return list.get(0);
877         }
878     }
879 
880     public MBMessageFlag findByThreadId_Last(long threadId,
881         OrderByComparator obc)
882         throws NoSuchMessageFlagException, SystemException {
883         int count = countByThreadId(threadId);
884 
885         List<MBMessageFlag> list = findByThreadId(threadId, count - 1, count,
886                 obc);
887 
888         if (list.isEmpty()) {
889             StringBuilder msg = new StringBuilder();
890 
891             msg.append("No MBMessageFlag exists with the key {");
892 
893             msg.append("threadId=" + threadId);
894 
895             msg.append(StringPool.CLOSE_CURLY_BRACE);
896 
897             throw new NoSuchMessageFlagException(msg.toString());
898         }
899         else {
900             return list.get(0);
901         }
902     }
903 
904     public MBMessageFlag[] findByThreadId_PrevAndNext(long messageFlagId,
905         long threadId, OrderByComparator obc)
906         throws NoSuchMessageFlagException, SystemException {
907         MBMessageFlag mbMessageFlag = findByPrimaryKey(messageFlagId);
908 
909         int count = countByThreadId(threadId);
910 
911         Session session = null;
912 
913         try {
914             session = openSession();
915 
916             StringBuilder query = new StringBuilder();
917 
918             query.append(
919                 "SELECT mbMessageFlag FROM MBMessageFlag mbMessageFlag WHERE ");
920 
921             query.append("mbMessageFlag.threadId = ?");
922 
923             query.append(" ");
924 
925             if (obc != null) {
926                 query.append("ORDER BY ");
927 
928                 String[] orderByFields = obc.getOrderByFields();
929 
930                 for (int i = 0; i < orderByFields.length; i++) {
931                     query.append("mbMessageFlag.");
932                     query.append(orderByFields[i]);
933 
934                     if (obc.isAscending()) {
935                         query.append(" ASC");
936                     }
937                     else {
938                         query.append(" DESC");
939                     }
940 
941                     if ((i + 1) < orderByFields.length) {
942                         query.append(", ");
943                     }
944                 }
945             }
946 
947             Query q = session.createQuery(query.toString());
948 
949             QueryPos qPos = QueryPos.getInstance(q);
950 
951             qPos.add(threadId);
952 
953             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
954                     mbMessageFlag);
955 
956             MBMessageFlag[] array = new MBMessageFlagImpl[3];
957 
958             array[0] = (MBMessageFlag)objArray[0];
959             array[1] = (MBMessageFlag)objArray[1];
960             array[2] = (MBMessageFlag)objArray[2];
961 
962             return array;
963         }
964         catch (Exception e) {
965             throw processException(e);
966         }
967         finally {
968             closeSession(session);
969         }
970     }
971 
972     public List<MBMessageFlag> findByMessageId(long messageId)
973         throws SystemException {
974         Object[] finderArgs = new Object[] { new Long(messageId) };
975 
976         List<MBMessageFlag> list = (List<MBMessageFlag>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_MESSAGEID,
977                 finderArgs, this);
978 
979         if (list == null) {
980             Session session = null;
981 
982             try {
983                 session = openSession();
984 
985                 StringBuilder query = new StringBuilder();
986 
987                 query.append(
988                     "SELECT mbMessageFlag FROM MBMessageFlag mbMessageFlag WHERE ");
989 
990                 query.append("mbMessageFlag.messageId = ?");
991 
992                 query.append(" ");
993 
994                 Query q = session.createQuery(query.toString());
995 
996                 QueryPos qPos = QueryPos.getInstance(q);
997 
998                 qPos.add(messageId);
999 
1000                list = q.list();
1001            }
1002            catch (Exception e) {
1003                throw processException(e);
1004            }
1005            finally {
1006                if (list == null) {
1007                    list = new ArrayList<MBMessageFlag>();
1008                }
1009
1010                cacheResult(list);
1011
1012                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_MESSAGEID,
1013                    finderArgs, list);
1014
1015                closeSession(session);
1016            }
1017        }
1018
1019        return list;
1020    }
1021
1022    public List<MBMessageFlag> findByMessageId(long messageId, int start,
1023        int end) throws SystemException {
1024        return findByMessageId(messageId, start, end, null);
1025    }
1026
1027    public List<MBMessageFlag> findByMessageId(long messageId, int start,
1028        int end, OrderByComparator obc) throws SystemException {
1029        Object[] finderArgs = new Object[] {
1030                new Long(messageId),
1031                
1032                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1033            };
1034
1035        List<MBMessageFlag> list = (List<MBMessageFlag>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_MESSAGEID,
1036                finderArgs, this);
1037
1038        if (list == null) {
1039            Session session = null;
1040
1041            try {
1042                session = openSession();
1043
1044                StringBuilder query = new StringBuilder();
1045
1046                query.append(
1047                    "SELECT mbMessageFlag FROM MBMessageFlag mbMessageFlag WHERE ");
1048
1049                query.append("mbMessageFlag.messageId = ?");
1050
1051                query.append(" ");
1052
1053                if (obc != null) {
1054                    query.append("ORDER BY ");
1055
1056                    String[] orderByFields = obc.getOrderByFields();
1057
1058                    for (int i = 0; i < orderByFields.length; i++) {
1059                        query.append("mbMessageFlag.");
1060                        query.append(orderByFields[i]);
1061
1062                        if (obc.isAscending()) {
1063                            query.append(" ASC");
1064                        }
1065                        else {
1066                            query.append(" DESC");
1067                        }
1068
1069                        if ((i + 1) < orderByFields.length) {
1070                            query.append(", ");
1071                        }
1072                    }
1073                }
1074
1075                Query q = session.createQuery(query.toString());
1076
1077                QueryPos qPos = QueryPos.getInstance(q);
1078
1079                qPos.add(messageId);
1080
1081                list = (List<MBMessageFlag>)QueryUtil.list(q, getDialect(),
1082                        start, end);
1083            }
1084            catch (Exception e) {
1085                throw processException(e);
1086            }
1087            finally {
1088                if (list == null) {
1089                    list = new ArrayList<MBMessageFlag>();
1090                }
1091
1092                cacheResult(list);
1093
1094                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_MESSAGEID,
1095                    finderArgs, list);
1096
1097                closeSession(session);
1098            }
1099        }
1100
1101        return list;
1102    }
1103
1104    public MBMessageFlag findByMessageId_First(long messageId,
1105        OrderByComparator obc)
1106        throws NoSuchMessageFlagException, SystemException {
1107        List<MBMessageFlag> list = findByMessageId(messageId, 0, 1, obc);
1108
1109        if (list.isEmpty()) {
1110            StringBuilder msg = new StringBuilder();
1111
1112            msg.append("No MBMessageFlag exists with the key {");
1113
1114            msg.append("messageId=" + messageId);
1115
1116            msg.append(StringPool.CLOSE_CURLY_BRACE);
1117
1118            throw new NoSuchMessageFlagException(msg.toString());
1119        }
1120        else {
1121            return list.get(0);
1122        }
1123    }
1124
1125    public MBMessageFlag findByMessageId_Last(long messageId,
1126        OrderByComparator obc)
1127        throws NoSuchMessageFlagException, SystemException {
1128        int count = countByMessageId(messageId);
1129
1130        List<MBMessageFlag> list = findByMessageId(messageId, count - 1, count,
1131                obc);
1132
1133        if (list.isEmpty()) {
1134            StringBuilder msg = new StringBuilder();
1135
1136            msg.append("No MBMessageFlag exists with the key {");
1137
1138            msg.append("messageId=" + messageId);
1139
1140            msg.append(StringPool.CLOSE_CURLY_BRACE);
1141
1142            throw new NoSuchMessageFlagException(msg.toString());
1143        }
1144        else {
1145            return list.get(0);
1146        }
1147    }
1148
1149    public MBMessageFlag[] findByMessageId_PrevAndNext(long messageFlagId,
1150        long messageId, OrderByComparator obc)
1151        throws NoSuchMessageFlagException, SystemException {
1152        MBMessageFlag mbMessageFlag = findByPrimaryKey(messageFlagId);
1153
1154        int count = countByMessageId(messageId);
1155
1156        Session session = null;
1157
1158        try {
1159            session = openSession();
1160
1161            StringBuilder query = new StringBuilder();
1162
1163            query.append(
1164                "SELECT mbMessageFlag FROM MBMessageFlag mbMessageFlag WHERE ");
1165
1166            query.append("mbMessageFlag.messageId = ?");
1167
1168            query.append(" ");
1169
1170            if (obc != null) {
1171                query.append("ORDER BY ");
1172
1173                String[] orderByFields = obc.getOrderByFields();
1174
1175                for (int i = 0; i < orderByFields.length; i++) {
1176                    query.append("mbMessageFlag.");
1177                    query.append(orderByFields[i]);
1178
1179                    if (obc.isAscending()) {
1180                        query.append(" ASC");
1181                    }
1182                    else {
1183                        query.append(" DESC");
1184                    }
1185
1186                    if ((i + 1) < orderByFields.length) {
1187                        query.append(", ");
1188                    }
1189                }
1190            }
1191
1192            Query q = session.createQuery(query.toString());
1193
1194            QueryPos qPos = QueryPos.getInstance(q);
1195
1196            qPos.add(messageId);
1197
1198            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1199                    mbMessageFlag);
1200
1201            MBMessageFlag[] array = new MBMessageFlagImpl[3];
1202
1203            array[0] = (MBMessageFlag)objArray[0];
1204            array[1] = (MBMessageFlag)objArray[1];
1205            array[2] = (MBMessageFlag)objArray[2];
1206
1207            return array;
1208        }
1209        catch (Exception e) {
1210            throw processException(e);
1211        }
1212        finally {
1213            closeSession(session);
1214        }
1215    }
1216
1217    public List<MBMessageFlag> findByT_F(long threadId, int flag)
1218        throws SystemException {
1219        Object[] finderArgs = new Object[] { new Long(threadId), new Integer(flag) };
1220
1221        List<MBMessageFlag> list = (List<MBMessageFlag>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_T_F,
1222                finderArgs, this);
1223
1224        if (list == null) {
1225            Session session = null;
1226
1227            try {
1228                session = openSession();
1229
1230                StringBuilder query = new StringBuilder();
1231
1232                query.append(
1233                    "SELECT mbMessageFlag FROM MBMessageFlag mbMessageFlag WHERE ");
1234
1235                query.append("mbMessageFlag.threadId = ?");
1236
1237                query.append(" AND ");
1238
1239                query.append("mbMessageFlag.flag = ?");
1240
1241                query.append(" ");
1242
1243                Query q = session.createQuery(query.toString());
1244
1245                QueryPos qPos = QueryPos.getInstance(q);
1246
1247                qPos.add(threadId);
1248
1249                qPos.add(flag);
1250
1251                list = q.list();
1252            }
1253            catch (Exception e) {
1254                throw processException(e);
1255            }
1256            finally {
1257                if (list == null) {
1258                    list = new ArrayList<MBMessageFlag>();
1259                }
1260
1261                cacheResult(list);
1262
1263                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_T_F, finderArgs,
1264                    list);
1265
1266                closeSession(session);
1267            }
1268        }
1269
1270        return list;
1271    }
1272
1273    public List<MBMessageFlag> findByT_F(long threadId, int flag, int start,
1274        int end) throws SystemException {
1275        return findByT_F(threadId, flag, start, end, null);
1276    }
1277
1278    public List<MBMessageFlag> findByT_F(long threadId, int flag, int start,
1279        int end, OrderByComparator obc) throws SystemException {
1280        Object[] finderArgs = new Object[] {
1281                new Long(threadId), new Integer(flag),
1282                
1283                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1284            };
1285
1286        List<MBMessageFlag> list = (List<MBMessageFlag>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_T_F,
1287                finderArgs, this);
1288
1289        if (list == null) {
1290            Session session = null;
1291
1292            try {
1293                session = openSession();
1294
1295                StringBuilder query = new StringBuilder();
1296
1297                query.append(
1298                    "SELECT mbMessageFlag FROM MBMessageFlag mbMessageFlag WHERE ");
1299
1300                query.append("mbMessageFlag.threadId = ?");
1301
1302                query.append(" AND ");
1303
1304                query.append("mbMessageFlag.flag = ?");
1305
1306                query.append(" ");
1307
1308                if (obc != null) {
1309                    query.append("ORDER BY ");
1310
1311                    String[] orderByFields = obc.getOrderByFields();
1312
1313                    for (int i = 0; i < orderByFields.length; i++) {
1314                        query.append("mbMessageFlag.");
1315                        query.append(orderByFields[i]);
1316
1317                        if (obc.isAscending()) {
1318                            query.append(" ASC");
1319                        }
1320                        else {
1321                            query.append(" DESC");
1322                        }
1323
1324                        if ((i + 1) < orderByFields.length) {
1325                            query.append(", ");
1326                        }
1327                    }
1328                }
1329
1330                Query q = session.createQuery(query.toString());
1331
1332                QueryPos qPos = QueryPos.getInstance(q);
1333
1334                qPos.add(threadId);
1335
1336                qPos.add(flag);
1337
1338                list = (List<MBMessageFlag>)QueryUtil.list(q, getDialect(),
1339                        start, end);
1340            }
1341            catch (Exception e) {
1342                throw processException(e);
1343            }
1344            finally {
1345                if (list == null) {
1346                    list = new ArrayList<MBMessageFlag>();
1347                }
1348
1349                cacheResult(list);
1350
1351                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_T_F,
1352                    finderArgs, list);
1353
1354                closeSession(session);
1355            }
1356        }
1357
1358        return list;
1359    }
1360
1361    public MBMessageFlag findByT_F_First(long threadId, int flag,
1362        OrderByComparator obc)
1363        throws NoSuchMessageFlagException, SystemException {
1364        List<MBMessageFlag> list = findByT_F(threadId, flag, 0, 1, obc);
1365
1366        if (list.isEmpty()) {
1367            StringBuilder msg = new StringBuilder();
1368
1369            msg.append("No MBMessageFlag exists with the key {");
1370
1371            msg.append("threadId=" + threadId);
1372
1373            msg.append(", ");
1374            msg.append("flag=" + flag);
1375
1376            msg.append(StringPool.CLOSE_CURLY_BRACE);
1377
1378            throw new NoSuchMessageFlagException(msg.toString());
1379        }
1380        else {
1381            return list.get(0);
1382        }
1383    }
1384
1385    public MBMessageFlag findByT_F_Last(long threadId, int flag,
1386        OrderByComparator obc)
1387        throws NoSuchMessageFlagException, SystemException {
1388        int count = countByT_F(threadId, flag);
1389
1390        List<MBMessageFlag> list = findByT_F(threadId, flag, count - 1, count,
1391                obc);
1392
1393        if (list.isEmpty()) {
1394            StringBuilder msg = new StringBuilder();
1395
1396            msg.append("No MBMessageFlag exists with the key {");
1397
1398            msg.append("threadId=" + threadId);
1399
1400            msg.append(", ");
1401            msg.append("flag=" + flag);
1402
1403            msg.append(StringPool.CLOSE_CURLY_BRACE);
1404
1405            throw new NoSuchMessageFlagException(msg.toString());
1406        }
1407        else {
1408            return list.get(0);
1409        }
1410    }
1411
1412    public MBMessageFlag[] findByT_F_PrevAndNext(long messageFlagId,
1413        long threadId, int flag, OrderByComparator obc)
1414        throws NoSuchMessageFlagException, SystemException {
1415        MBMessageFlag mbMessageFlag = findByPrimaryKey(messageFlagId);
1416
1417        int count = countByT_F(threadId, flag);
1418
1419        Session session = null;
1420
1421        try {
1422            session = openSession();
1423
1424            StringBuilder query = new StringBuilder();
1425
1426            query.append(
1427                "SELECT mbMessageFlag FROM MBMessageFlag mbMessageFlag WHERE ");
1428
1429            query.append("mbMessageFlag.threadId = ?");
1430
1431            query.append(" AND ");
1432
1433            query.append("mbMessageFlag.flag = ?");
1434
1435            query.append(" ");
1436
1437            if (obc != null) {
1438                query.append("ORDER BY ");
1439
1440                String[] orderByFields = obc.getOrderByFields();
1441
1442                for (int i = 0; i < orderByFields.length; i++) {
1443                    query.append("mbMessageFlag.");
1444                    query.append(orderByFields[i]);
1445
1446                    if (obc.isAscending()) {
1447                        query.append(" ASC");
1448                    }
1449                    else {
1450                        query.append(" DESC");
1451                    }
1452
1453                    if ((i + 1) < orderByFields.length) {
1454                        query.append(", ");
1455                    }
1456                }
1457            }
1458
1459            Query q = session.createQuery(query.toString());
1460
1461            QueryPos qPos = QueryPos.getInstance(q);
1462
1463            qPos.add(threadId);
1464
1465            qPos.add(flag);
1466
1467            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1468                    mbMessageFlag);
1469
1470            MBMessageFlag[] array = new MBMessageFlagImpl[3];
1471
1472            array[0] = (MBMessageFlag)objArray[0];
1473            array[1] = (MBMessageFlag)objArray[1];
1474            array[2] = (MBMessageFlag)objArray[2];
1475
1476            return array;
1477        }
1478        catch (Exception e) {
1479            throw processException(e);
1480        }
1481        finally {
1482            closeSession(session);
1483        }
1484    }
1485
1486    public List<MBMessageFlag> findByM_F(long messageId, int flag)
1487        throws SystemException {
1488        Object[] finderArgs = new Object[] {
1489                new Long(messageId), new Integer(flag)
1490            };
1491
1492        List<MBMessageFlag> list = (List<MBMessageFlag>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_M_F,
1493                finderArgs, this);
1494
1495        if (list == null) {
1496            Session session = null;
1497
1498            try {
1499                session = openSession();
1500
1501                StringBuilder query = new StringBuilder();
1502
1503                query.append(
1504                    "SELECT mbMessageFlag FROM MBMessageFlag mbMessageFlag WHERE ");
1505
1506                query.append("mbMessageFlag.messageId = ?");
1507
1508                query.append(" AND ");
1509
1510                query.append("mbMessageFlag.flag = ?");
1511
1512                query.append(" ");
1513
1514                Query q = session.createQuery(query.toString());
1515
1516                QueryPos qPos = QueryPos.getInstance(q);
1517
1518                qPos.add(messageId);
1519
1520                qPos.add(flag);
1521
1522                list = q.list();
1523            }
1524            catch (Exception e) {
1525                throw processException(e);
1526            }
1527            finally {
1528                if (list == null) {
1529                    list = new ArrayList<MBMessageFlag>();
1530                }
1531
1532                cacheResult(list);
1533
1534                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_M_F, finderArgs,
1535                    list);
1536
1537                closeSession(session);
1538            }
1539        }
1540
1541        return list;
1542    }
1543
1544    public List<MBMessageFlag> findByM_F(long messageId, int flag, int start,
1545        int end) throws SystemException {
1546        return findByM_F(messageId, flag, start, end, null);
1547    }
1548
1549    public List<MBMessageFlag> findByM_F(long messageId, int flag, int start,
1550        int end, OrderByComparator obc) throws SystemException {
1551        Object[] finderArgs = new Object[] {
1552                new Long(messageId), new Integer(flag),
1553                
1554                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1555            };
1556
1557        List<MBMessageFlag> list = (List<MBMessageFlag>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_M_F,
1558                finderArgs, this);
1559
1560        if (list == null) {
1561            Session session = null;
1562
1563            try {
1564                session = openSession();
1565
1566                StringBuilder query = new StringBuilder();
1567
1568                query.append(
1569                    "SELECT mbMessageFlag FROM MBMessageFlag mbMessageFlag WHERE ");
1570
1571                query.append("mbMessageFlag.messageId = ?");
1572
1573                query.append(" AND ");
1574
1575                query.append("mbMessageFlag.flag = ?");
1576
1577                query.append(" ");
1578
1579                if (obc != null) {
1580                    query.append("ORDER BY ");
1581
1582                    String[] orderByFields = obc.getOrderByFields();
1583
1584                    for (int i = 0; i < orderByFields.length; i++) {
1585                        query.append("mbMessageFlag.");
1586                        query.append(orderByFields[i]);
1587
1588                        if (obc.isAscending()) {
1589                            query.append(" ASC");
1590                        }
1591                        else {
1592                            query.append(" DESC");
1593                        }
1594
1595                        if ((i + 1) < orderByFields.length) {
1596                            query.append(", ");
1597                        }
1598                    }
1599                }
1600
1601                Query q = session.createQuery(query.toString());
1602
1603                QueryPos qPos = QueryPos.getInstance(q);
1604
1605                qPos.add(messageId);
1606
1607                qPos.add(flag);
1608
1609                list = (List<MBMessageFlag>)QueryUtil.list(q, getDialect(),
1610                        start, end);
1611            }
1612            catch (Exception e) {
1613                throw processException(e);
1614            }
1615            finally {
1616                if (list == null) {
1617                    list = new ArrayList<MBMessageFlag>();
1618                }
1619
1620                cacheResult(list);
1621
1622                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_M_F,
1623                    finderArgs, list);
1624
1625                closeSession(session);
1626            }
1627        }
1628
1629        return list;
1630    }
1631
1632    public MBMessageFlag findByM_F_First(long messageId, int flag,
1633        OrderByComparator obc)
1634        throws NoSuchMessageFlagException, SystemException {
1635        List<MBMessageFlag> list = findByM_F(messageId, flag, 0, 1, obc);
1636
1637        if (list.isEmpty()) {
1638            StringBuilder msg = new StringBuilder();
1639
1640            msg.append("No MBMessageFlag exists with the key {");
1641
1642            msg.append("messageId=" + messageId);
1643
1644            msg.append(", ");
1645            msg.append("flag=" + flag);
1646
1647            msg.append(StringPool.CLOSE_CURLY_BRACE);
1648
1649            throw new NoSuchMessageFlagException(msg.toString());
1650        }
1651        else {
1652            return list.get(0);
1653        }
1654    }
1655
1656    public MBMessageFlag findByM_F_Last(long messageId, int flag,
1657        OrderByComparator obc)
1658        throws NoSuchMessageFlagException, SystemException {
1659        int count = countByM_F(messageId, flag);
1660
1661        List<MBMessageFlag> list = findByM_F(messageId, flag, count - 1, count,
1662                obc);
1663
1664        if (list.isEmpty()) {
1665            StringBuilder msg = new StringBuilder();
1666
1667            msg.append("No MBMessageFlag exists with the key {");
1668
1669            msg.append("messageId=" + messageId);
1670
1671            msg.append(", ");
1672            msg.append("flag=" + flag);
1673
1674            msg.append(StringPool.CLOSE_CURLY_BRACE);
1675
1676            throw new NoSuchMessageFlagException(msg.toString());
1677        }
1678        else {
1679            return list.get(0);
1680        }
1681    }
1682
1683    public MBMessageFlag[] findByM_F_PrevAndNext(long messageFlagId,
1684        long messageId, int flag, OrderByComparator obc)
1685        throws NoSuchMessageFlagException, SystemException {
1686        MBMessageFlag mbMessageFlag = findByPrimaryKey(messageFlagId);
1687
1688        int count = countByM_F(messageId, flag);
1689
1690        Session session = null;
1691
1692        try {
1693            session = openSession();
1694
1695            StringBuilder query = new StringBuilder();
1696
1697            query.append(
1698                "SELECT mbMessageFlag FROM MBMessageFlag mbMessageFlag WHERE ");
1699
1700            query.append("mbMessageFlag.messageId = ?");
1701
1702            query.append(" AND ");
1703
1704            query.append("mbMessageFlag.flag = ?");
1705
1706            query.append(" ");
1707
1708            if (obc != null) {
1709                query.append("ORDER BY ");
1710
1711                String[] orderByFields = obc.getOrderByFields();
1712
1713                for (int i = 0; i < orderByFields.length; i++) {
1714                    query.append("mbMessageFlag.");
1715                    query.append(orderByFields[i]);
1716
1717                    if (obc.isAscending()) {
1718                        query.append(" ASC");
1719                    }
1720                    else {
1721                        query.append(" DESC");
1722                    }
1723
1724                    if ((i + 1) < orderByFields.length) {
1725                        query.append(", ");
1726                    }
1727                }
1728            }
1729
1730            Query q = session.createQuery(query.toString());
1731
1732            QueryPos qPos = QueryPos.getInstance(q);
1733
1734            qPos.add(messageId);
1735
1736            qPos.add(flag);
1737
1738            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1739                    mbMessageFlag);
1740
1741            MBMessageFlag[] array = new MBMessageFlagImpl[3];
1742
1743            array[0] = (MBMessageFlag)objArray[0];
1744            array[1] = (MBMessageFlag)objArray[1];
1745            array[2] = (MBMessageFlag)objArray[2];
1746
1747            return array;
1748        }
1749        catch (Exception e) {
1750            throw processException(e);
1751        }
1752        finally {
1753            closeSession(session);
1754        }
1755    }
1756
1757    public List<MBMessageFlag> findByU_T_F(long userId, long threadId, int flag)
1758        throws SystemException {
1759        Object[] finderArgs = new Object[] {
1760                new Long(userId), new Long(threadId), new Integer(flag)
1761            };
1762
1763        List<MBMessageFlag> list = (List<MBMessageFlag>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_U_T_F,
1764                finderArgs, this);
1765
1766        if (list == null) {
1767            Session session = null;
1768
1769            try {
1770                session = openSession();
1771
1772                StringBuilder query = new StringBuilder();
1773
1774                query.append(
1775                    "SELECT mbMessageFlag FROM MBMessageFlag mbMessageFlag WHERE ");
1776
1777                query.append("mbMessageFlag.userId = ?");
1778
1779                query.append(" AND ");
1780
1781                query.append("mbMessageFlag.threadId = ?");
1782
1783                query.append(" AND ");
1784
1785                query.append("mbMessageFlag.flag = ?");
1786
1787                query.append(" ");
1788
1789                Query q = session.createQuery(query.toString());
1790
1791                QueryPos qPos = QueryPos.getInstance(q);
1792
1793                qPos.add(userId);
1794
1795                qPos.add(threadId);
1796
1797                qPos.add(flag);
1798
1799                list = q.list();
1800            }
1801            catch (Exception e) {
1802                throw processException(e);
1803            }
1804            finally {
1805                if (list == null) {
1806                    list = new ArrayList<MBMessageFlag>();
1807                }
1808
1809                cacheResult(list);
1810
1811                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_U_T_F,
1812                    finderArgs, list);
1813
1814                closeSession(session);
1815            }
1816        }
1817
1818        return list;
1819    }
1820
1821    public List<MBMessageFlag> findByU_T_F(long userId, long threadId,
1822        int flag, int start, int end) throws SystemException {
1823        return findByU_T_F(userId, threadId, flag, start, end, null);
1824    }
1825
1826    public List<MBMessageFlag> findByU_T_F(long userId, long threadId,
1827        int flag, int start, int end, OrderByComparator obc)
1828        throws SystemException {
1829        Object[] finderArgs = new Object[] {
1830                new Long(userId), new Long(threadId), new Integer(flag),
1831                
1832                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1833            };
1834
1835        List<MBMessageFlag> list = (List<MBMessageFlag>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_U_T_F,
1836                finderArgs, this);
1837
1838        if (list == null) {
1839            Session session = null;
1840
1841            try {
1842                session = openSession();
1843
1844                StringBuilder query = new StringBuilder();
1845
1846                query.append(
1847                    "SELECT mbMessageFlag FROM MBMessageFlag mbMessageFlag WHERE ");
1848
1849                query.append("mbMessageFlag.userId = ?");
1850
1851                query.append(" AND ");
1852
1853                query.append("mbMessageFlag.threadId = ?");
1854
1855                query.append(" AND ");
1856
1857                query.append("mbMessageFlag.flag = ?");
1858
1859                query.append(" ");
1860
1861                if (obc != null) {
1862                    query.append("ORDER BY ");
1863
1864                    String[] orderByFields = obc.getOrderByFields();
1865
1866                    for (int i = 0; i < orderByFields.length; i++) {
1867                        query.append("mbMessageFlag.");
1868                        query.append(orderByFields[i]);
1869
1870                        if (obc.isAscending()) {
1871                            query.append(" ASC");
1872                        }
1873                        else {
1874                            query.append(" DESC");
1875                        }
1876
1877                        if ((i + 1) < orderByFields.length) {
1878                            query.append(", ");
1879                        }
1880                    }
1881                }
1882
1883                Query q = session.createQuery(query.toString());
1884
1885                QueryPos qPos = QueryPos.getInstance(q);
1886
1887                qPos.add(userId);
1888
1889                qPos.add(threadId);
1890
1891                qPos.add(flag);
1892
1893                list = (List<MBMessageFlag>)QueryUtil.list(q, getDialect(),
1894                        start, end);
1895            }
1896            catch (Exception e) {
1897                throw processException(e);
1898            }
1899            finally {
1900                if (list == null) {
1901                    list = new ArrayList<MBMessageFlag>();
1902                }
1903
1904                cacheResult(list);
1905
1906                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_U_T_F,
1907                    finderArgs, list);
1908
1909                closeSession(session);
1910            }
1911        }
1912
1913        return list;
1914    }
1915
1916    public MBMessageFlag findByU_T_F_First(long userId, long threadId,
1917        int flag, OrderByComparator obc)
1918        throws NoSuchMessageFlagException, SystemException {
1919        List<MBMessageFlag> list = findByU_T_F(userId, threadId, flag, 0, 1, obc);
1920
1921        if (list.isEmpty()) {
1922            StringBuilder msg = new StringBuilder();
1923
1924            msg.append("No MBMessageFlag exists with the key {");
1925
1926            msg.append("userId=" + userId);
1927
1928            msg.append(", ");
1929            msg.append("threadId=" + threadId);
1930
1931            msg.append(", ");
1932            msg.append("flag=" + flag);
1933
1934            msg.append(StringPool.CLOSE_CURLY_BRACE);
1935
1936            throw new NoSuchMessageFlagException(msg.toString());
1937        }
1938        else {
1939            return list.get(0);
1940        }
1941    }
1942
1943    public MBMessageFlag findByU_T_F_Last(long userId, long threadId, int flag,
1944        OrderByComparator obc)
1945        throws NoSuchMessageFlagException, SystemException {
1946        int count = countByU_T_F(userId, threadId, flag);
1947
1948        List<MBMessageFlag> list = findByU_T_F(userId, threadId, flag,
1949                count - 1, count, obc);
1950
1951        if (list.isEmpty()) {
1952            StringBuilder msg = new StringBuilder();
1953
1954            msg.append("No MBMessageFlag exists with the key {");
1955
1956            msg.append("userId=" + userId);
1957
1958            msg.append(", ");
1959            msg.append("threadId=" + threadId);
1960
1961            msg.append(", ");
1962            msg.append("flag=" + flag);
1963
1964            msg.append(StringPool.CLOSE_CURLY_BRACE);
1965
1966            throw new NoSuchMessageFlagException(msg.toString());
1967        }
1968        else {
1969            return list.get(0);
1970        }
1971    }
1972
1973    public MBMessageFlag[] findByU_T_F_PrevAndNext(long messageFlagId,
1974        long userId, long threadId, int flag, OrderByComparator obc)
1975        throws NoSuchMessageFlagException, SystemException {
1976        MBMessageFlag mbMessageFlag = findByPrimaryKey(messageFlagId);
1977
1978        int count = countByU_T_F(userId, threadId, flag);
1979
1980        Session session = null;
1981
1982        try {
1983            session = openSession();
1984
1985            StringBuilder query = new StringBuilder();
1986
1987            query.append(
1988                "SELECT mbMessageFlag FROM MBMessageFlag mbMessageFlag WHERE ");
1989
1990            query.append("mbMessageFlag.userId = ?");
1991
1992            query.append(" AND ");
1993
1994            query.append("mbMessageFlag.threadId = ?");
1995
1996            query.append(" AND ");
1997
1998            query.append("mbMessageFlag.flag = ?");
1999
2000            query.append(" ");
2001
2002            if (obc != null) {
2003                query.append("ORDER BY ");
2004
2005                String[] orderByFields = obc.getOrderByFields();
2006
2007                for (int i = 0; i < orderByFields.length; i++) {
2008                    query.append("mbMessageFlag.");
2009                    query.append(orderByFields[i]);
2010
2011                    if (obc.isAscending()) {
2012                        query.append(" ASC");
2013                    }
2014                    else {
2015                        query.append(" DESC");
2016                    }
2017
2018                    if ((i + 1) < orderByFields.length) {
2019                        query.append(", ");
2020                    }
2021                }
2022            }
2023
2024            Query q = session.createQuery(query.toString());
2025
2026            QueryPos qPos = QueryPos.getInstance(q);
2027
2028            qPos.add(userId);
2029
2030            qPos.add(threadId);
2031
2032            qPos.add(flag);
2033
2034            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
2035                    mbMessageFlag);
2036
2037            MBMessageFlag[] array = new MBMessageFlagImpl[3];
2038
2039            array[0] = (MBMessageFlag)objArray[0];
2040            array[1] = (MBMessageFlag)objArray[1];
2041            array[2] = (MBMessageFlag)objArray[2];
2042
2043            return array;
2044        }
2045        catch (Exception e) {
2046            throw processException(e);
2047        }
2048        finally {
2049            closeSession(session);
2050        }
2051    }
2052
2053    public MBMessageFlag findByU_M_F(long userId, long messageId, int flag)
2054        throws NoSuchMessageFlagException, SystemException {
2055        MBMessageFlag mbMessageFlag = fetchByU_M_F(userId, messageId, flag);
2056
2057        if (mbMessageFlag == null) {
2058            StringBuilder msg = new StringBuilder();
2059
2060            msg.append("No MBMessageFlag exists with the key {");
2061
2062            msg.append("userId=" + userId);
2063
2064            msg.append(", ");
2065            msg.append("messageId=" + messageId);
2066
2067            msg.append(", ");
2068            msg.append("flag=" + flag);
2069
2070            msg.append(StringPool.CLOSE_CURLY_BRACE);
2071
2072            if (_log.isWarnEnabled()) {
2073                _log.warn(msg.toString());
2074            }
2075
2076            throw new NoSuchMessageFlagException(msg.toString());
2077        }
2078
2079        return mbMessageFlag;
2080    }
2081
2082    public MBMessageFlag fetchByU_M_F(long userId, long messageId, int flag)
2083        throws SystemException {
2084        return fetchByU_M_F(userId, messageId, flag, true);
2085    }
2086
2087    public MBMessageFlag fetchByU_M_F(long userId, long messageId, int flag,
2088        boolean retrieveFromCache) throws SystemException {
2089        Object[] finderArgs = new Object[] {
2090                new Long(userId), new Long(messageId), new Integer(flag)
2091            };
2092
2093        Object result = null;
2094
2095        if (retrieveFromCache) {
2096            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_U_M_F,
2097                    finderArgs, this);
2098        }
2099
2100        if (result == null) {
2101            Session session = null;
2102
2103            try {
2104                session = openSession();
2105
2106                StringBuilder query = new StringBuilder();
2107
2108                query.append(
2109                    "SELECT mbMessageFlag FROM MBMessageFlag mbMessageFlag WHERE ");
2110
2111                query.append("mbMessageFlag.userId = ?");
2112
2113                query.append(" AND ");
2114
2115                query.append("mbMessageFlag.messageId = ?");
2116
2117                query.append(" AND ");
2118
2119                query.append("mbMessageFlag.flag = ?");
2120
2121                query.append(" ");
2122
2123                Query q = session.createQuery(query.toString());
2124
2125                QueryPos qPos = QueryPos.getInstance(q);
2126
2127                qPos.add(userId);
2128
2129                qPos.add(messageId);
2130
2131                qPos.add(flag);
2132
2133                List<MBMessageFlag> list = q.list();
2134
2135                result = list;
2136
2137                MBMessageFlag mbMessageFlag = null;
2138
2139                if (list.isEmpty()) {
2140                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_U_M_F,
2141                        finderArgs, list);
2142                }
2143                else {
2144                    mbMessageFlag = list.get(0);
2145
2146                    cacheResult(mbMessageFlag);
2147
2148                    if ((mbMessageFlag.getUserId() != userId) ||
2149                            (mbMessageFlag.getMessageId() != messageId) ||
2150                            (mbMessageFlag.getFlag() != flag)) {
2151                        FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_U_M_F,
2152                            finderArgs, mbMessageFlag);
2153                    }
2154                }
2155
2156                return mbMessageFlag;
2157            }
2158            catch (Exception e) {
2159                throw processException(e);
2160            }
2161            finally {
2162                if (result == null) {
2163                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_U_M_F,
2164                        finderArgs, new ArrayList<MBMessageFlag>());
2165                }
2166
2167                closeSession(session);
2168            }
2169        }
2170        else {
2171            if (result instanceof List) {
2172                return null;
2173            }
2174            else {
2175                return (MBMessageFlag)result;
2176            }
2177        }
2178    }
2179
2180    public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery)
2181        throws SystemException {
2182        Session session = null;
2183
2184        try {
2185            session = openSession();
2186
2187            dynamicQuery.compile(session);
2188
2189            return dynamicQuery.list();
2190        }
2191        catch (Exception e) {
2192            throw processException(e);
2193        }
2194        finally {
2195            closeSession(session);
2196        }
2197    }
2198
2199    public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery,
2200        int start, int end) throws SystemException {
2201        Session session = null;
2202
2203        try {
2204            session = openSession();
2205
2206            dynamicQuery.setLimit(start, end);
2207
2208            dynamicQuery.compile(session);
2209
2210            return dynamicQuery.list();
2211        }
2212        catch (Exception e) {
2213            throw processException(e);
2214        }
2215        finally {
2216            closeSession(session);
2217        }
2218    }
2219
2220    public List<MBMessageFlag> findAll() throws SystemException {
2221        return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
2222    }
2223
2224    public List<MBMessageFlag> findAll(int start, int end)
2225        throws SystemException {
2226        return findAll(start, end, null);
2227    }
2228
2229    public List<MBMessageFlag> findAll(int start, int end, OrderByComparator obc)
2230        throws SystemException {
2231        Object[] finderArgs = new Object[] {
2232                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
2233            };
2234
2235        List<MBMessageFlag> list = (List<MBMessageFlag>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
2236                finderArgs, this);
2237
2238        if (list == null) {
2239            Session session = null;
2240
2241            try {
2242                session = openSession();
2243
2244                StringBuilder query = new StringBuilder();
2245
2246                query.append(
2247                    "SELECT mbMessageFlag FROM MBMessageFlag mbMessageFlag ");
2248
2249                if (obc != null) {
2250                    query.append("ORDER BY ");
2251
2252                    String[] orderByFields = obc.getOrderByFields();
2253
2254                    for (int i = 0; i < orderByFields.length; i++) {
2255                        query.append("mbMessageFlag.");
2256                        query.append(orderByFields[i]);
2257
2258                        if (obc.isAscending()) {
2259                            query.append(" ASC");
2260                        }
2261                        else {
2262                            query.append(" DESC");
2263                        }
2264
2265                        if ((i + 1) < orderByFields.length) {
2266                            query.append(", ");
2267                        }
2268                    }
2269                }
2270
2271                Query q = session.createQuery(query.toString());
2272
2273                if (obc == null) {
2274                    list = (List<MBMessageFlag>)QueryUtil.list(q, getDialect(),
2275                            start, end, false);
2276
2277                    Collections.sort(list);
2278                }
2279                else {
2280                    list = (List<MBMessageFlag>)QueryUtil.list(q, getDialect(),
2281                            start, end);
2282                }
2283            }
2284            catch (Exception e) {
2285                throw processException(e);
2286            }
2287            finally {
2288                if (list == null) {
2289                    list = new ArrayList<MBMessageFlag>();
2290                }
2291
2292                cacheResult(list);
2293
2294                FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
2295
2296                closeSession(session);
2297            }
2298        }
2299
2300        return list;
2301    }
2302
2303    public void removeByUserId(long userId) throws SystemException {
2304        for (MBMessageFlag mbMessageFlag : findByUserId(userId)) {
2305            remove(mbMessageFlag);
2306        }
2307    }
2308
2309    public void removeByThreadId(long threadId) throws SystemException {
2310        for (MBMessageFlag mbMessageFlag : findByThreadId(threadId)) {
2311            remove(mbMessageFlag);
2312        }
2313    }
2314
2315    public void removeByMessageId(long messageId) throws SystemException {
2316        for (MBMessageFlag mbMessageFlag : findByMessageId(messageId)) {
2317            remove(mbMessageFlag);
2318        }
2319    }
2320
2321    public void removeByT_F(long threadId, int flag) throws SystemException {
2322        for (MBMessageFlag mbMessageFlag : findByT_F(threadId, flag)) {
2323            remove(mbMessageFlag);
2324        }
2325    }
2326
2327    public void removeByM_F(long messageId, int flag) throws SystemException {
2328        for (MBMessageFlag mbMessageFlag : findByM_F(messageId, flag)) {
2329            remove(mbMessageFlag);
2330        }
2331    }
2332
2333    public void removeByU_T_F(long userId, long threadId, int flag)
2334        throws SystemException {
2335        for (MBMessageFlag mbMessageFlag : findByU_T_F(userId, threadId, flag)) {
2336            remove(mbMessageFlag);
2337        }
2338    }
2339
2340    public void removeByU_M_F(long userId, long messageId, int flag)
2341        throws NoSuchMessageFlagException, SystemException {
2342        MBMessageFlag mbMessageFlag = findByU_M_F(userId, messageId, flag);
2343
2344        remove(mbMessageFlag);
2345    }
2346
2347    public void removeAll() throws SystemException {
2348        for (MBMessageFlag mbMessageFlag : findAll()) {
2349            remove(mbMessageFlag);
2350        }
2351    }
2352
2353    public int countByUserId(long userId) throws SystemException {
2354        Object[] finderArgs = new Object[] { new Long(userId) };
2355
2356        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_USERID,
2357                finderArgs, this);
2358
2359        if (count == null) {
2360            Session session = null;
2361
2362            try {
2363                session = openSession();
2364
2365                StringBuilder query = new StringBuilder();
2366
2367                query.append("SELECT COUNT(mbMessageFlag) ");
2368                query.append("FROM MBMessageFlag mbMessageFlag WHERE ");
2369
2370                query.append("mbMessageFlag.userId = ?");
2371
2372                query.append(" ");
2373
2374                Query q = session.createQuery(query.toString());
2375
2376                QueryPos qPos = QueryPos.getInstance(q);
2377
2378                qPos.add(userId);
2379
2380                count = (Long)q.uniqueResult();
2381            }
2382            catch (Exception e) {
2383                throw processException(e);
2384            }
2385            finally {
2386                if (count == null) {
2387                    count = Long.valueOf(0);
2388                }
2389
2390                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_USERID,
2391                    finderArgs, count);
2392
2393                closeSession(session);
2394            }
2395        }
2396
2397        return count.intValue();
2398    }
2399
2400    public int countByThreadId(long threadId) throws SystemException {
2401        Object[] finderArgs = new Object[] { new Long(threadId) };
2402
2403        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_THREADID,
2404                finderArgs, this);
2405
2406        if (count == null) {
2407            Session session = null;
2408
2409            try {
2410                session = openSession();
2411
2412                StringBuilder query = new StringBuilder();
2413
2414                query.append("SELECT COUNT(mbMessageFlag) ");
2415                query.append("FROM MBMessageFlag mbMessageFlag WHERE ");
2416
2417                query.append("mbMessageFlag.threadId = ?");
2418
2419                query.append(" ");
2420
2421                Query q = session.createQuery(query.toString());
2422
2423                QueryPos qPos = QueryPos.getInstance(q);
2424
2425                qPos.add(threadId);
2426
2427                count = (Long)q.uniqueResult();
2428            }
2429            catch (Exception e) {
2430                throw processException(e);
2431            }
2432            finally {
2433                if (count == null) {
2434                    count = Long.valueOf(0);
2435                }
2436
2437                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_THREADID,
2438                    finderArgs, count);
2439
2440                closeSession(session);
2441            }
2442        }
2443
2444        return count.intValue();
2445    }
2446
2447    public int countByMessageId(long messageId) throws SystemException {
2448        Object[] finderArgs = new Object[] { new Long(messageId) };
2449
2450        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_MESSAGEID,
2451                finderArgs, this);
2452
2453        if (count == null) {
2454            Session session = null;
2455
2456            try {
2457                session = openSession();
2458
2459                StringBuilder query = new StringBuilder();
2460
2461                query.append("SELECT COUNT(mbMessageFlag) ");
2462                query.append("FROM MBMessageFlag mbMessageFlag WHERE ");
2463
2464                query.append("mbMessageFlag.messageId = ?");
2465
2466                query.append(" ");
2467
2468                Query q = session.createQuery(query.toString());
2469
2470                QueryPos qPos = QueryPos.getInstance(q);
2471
2472                qPos.add(messageId);
2473
2474                count = (Long)q.uniqueResult();
2475            }
2476            catch (Exception e) {
2477                throw processException(e);
2478            }
2479            finally {
2480                if (count == null) {
2481                    count = Long.valueOf(0);
2482                }
2483
2484                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_MESSAGEID,
2485                    finderArgs, count);
2486
2487                closeSession(session);
2488            }
2489        }
2490
2491        return count.intValue();
2492    }
2493
2494    public int countByT_F(long threadId, int flag) throws SystemException {
2495        Object[] finderArgs = new Object[] { new Long(threadId), new Integer(flag) };
2496
2497        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_T_F,
2498                finderArgs, this);
2499
2500        if (count == null) {
2501            Session session = null;
2502
2503            try {
2504                session = openSession();
2505
2506                StringBuilder query = new StringBuilder();
2507
2508                query.append("SELECT COUNT(mbMessageFlag) ");
2509                query.append("FROM MBMessageFlag mbMessageFlag WHERE ");
2510
2511                query.append("mbMessageFlag.threadId = ?");
2512
2513                query.append(" AND ");
2514
2515                query.append("mbMessageFlag.flag = ?");
2516
2517                query.append(" ");
2518
2519                Query q = session.createQuery(query.toString());
2520
2521                QueryPos qPos = QueryPos.getInstance(q);
2522
2523                qPos.add(threadId);
2524
2525                qPos.add(flag);
2526
2527                count = (Long)q.uniqueResult();
2528            }
2529            catch (Exception e) {
2530                throw processException(e);
2531            }
2532            finally {
2533                if (count == null) {
2534                    count = Long.valueOf(0);
2535                }
2536
2537                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_T_F, finderArgs,
2538                    count);
2539
2540                closeSession(session);
2541            }
2542        }
2543
2544        return count.intValue();
2545    }
2546
2547    public int countByM_F(long messageId, int flag) throws SystemException {
2548        Object[] finderArgs = new Object[] {
2549                new Long(messageId), new Integer(flag)
2550            };
2551
2552        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_M_F,
2553                finderArgs, this);
2554
2555        if (count == null) {
2556            Session session = null;
2557
2558            try {
2559                session = openSession();
2560
2561                StringBuilder query = new StringBuilder();
2562
2563                query.append("SELECT COUNT(mbMessageFlag) ");
2564                query.append("FROM MBMessageFlag mbMessageFlag WHERE ");
2565
2566                query.append("mbMessageFlag.messageId = ?");
2567
2568                query.append(" AND ");
2569
2570                query.append("mbMessageFlag.flag = ?");
2571
2572                query.append(" ");
2573
2574                Query q = session.createQuery(query.toString());
2575
2576                QueryPos qPos = QueryPos.getInstance(q);
2577
2578                qPos.add(messageId);
2579
2580                qPos.add(flag);
2581
2582                count = (Long)q.uniqueResult();
2583            }
2584            catch (Exception e) {
2585                throw processException(e);
2586            }
2587            finally {
2588                if (count == null) {
2589                    count = Long.valueOf(0);
2590                }
2591
2592                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_M_F, finderArgs,
2593                    count);
2594
2595                closeSession(session);
2596            }
2597        }
2598
2599        return count.intValue();
2600    }
2601
2602    public int countByU_T_F(long userId, long threadId, int flag)
2603        throws SystemException {
2604        Object[] finderArgs = new Object[] {
2605                new Long(userId), new Long(threadId), new Integer(flag)
2606            };
2607
2608        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_U_T_F,
2609                finderArgs, this);
2610
2611        if (count == null) {
2612            Session session = null;
2613
2614            try {
2615                session = openSession();
2616
2617                StringBuilder query = new StringBuilder();
2618
2619                query.append("SELECT COUNT(mbMessageFlag) ");
2620                query.append("FROM MBMessageFlag mbMessageFlag WHERE ");
2621
2622                query.append("mbMessageFlag.userId = ?");
2623
2624                query.append(" AND ");
2625
2626                query.append("mbMessageFlag.threadId = ?");
2627
2628                query.append(" AND ");
2629
2630                query.append("mbMessageFlag.flag = ?");
2631
2632                query.append(" ");
2633
2634                Query q = session.createQuery(query.toString());
2635
2636                QueryPos qPos = QueryPos.getInstance(q);
2637
2638                qPos.add(userId);
2639
2640                qPos.add(threadId);
2641
2642                qPos.add(flag);
2643
2644                count = (Long)q.uniqueResult();
2645            }
2646            catch (Exception e) {
2647                throw processException(e);
2648            }
2649            finally {
2650                if (count == null) {
2651                    count = Long.valueOf(0);
2652                }
2653
2654                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_U_T_F,
2655                    finderArgs, count);
2656
2657                closeSession(session);
2658            }
2659        }
2660
2661        return count.intValue();
2662    }
2663
2664    public int countByU_M_F(long userId, long messageId, int flag)
2665        throws SystemException {
2666        Object[] finderArgs = new Object[] {
2667                new Long(userId), new Long(messageId), new Integer(flag)
2668            };
2669
2670        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_U_M_F,
2671                finderArgs, this);
2672
2673        if (count == null) {
2674            Session session = null;
2675
2676            try {
2677                session = openSession();
2678
2679                StringBuilder query = new StringBuilder();
2680
2681                query.append("SELECT COUNT(mbMessageFlag) ");
2682                query.append("FROM MBMessageFlag mbMessageFlag WHERE ");
2683
2684                query.append("mbMessageFlag.userId = ?");
2685
2686                query.append(" AND ");
2687
2688                query.append("mbMessageFlag.messageId = ?");
2689
2690                query.append(" AND ");
2691
2692                query.append("mbMessageFlag.flag = ?");
2693
2694                query.append(" ");
2695
2696                Query q = session.createQuery(query.toString());
2697
2698                QueryPos qPos = QueryPos.getInstance(q);
2699
2700                qPos.add(userId);
2701
2702                qPos.add(messageId);
2703
2704                qPos.add(flag);
2705
2706                count = (Long)q.uniqueResult();
2707            }
2708            catch (Exception e) {
2709                throw processException(e);
2710            }
2711            finally {
2712                if (count == null) {
2713                    count = Long.valueOf(0);
2714                }
2715
2716                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_U_M_F,
2717                    finderArgs, count);
2718
2719                closeSession(session);
2720            }
2721        }
2722
2723        return count.intValue();
2724    }
2725
2726    public int countAll() throws SystemException {
2727        Object[] finderArgs = new Object[0];
2728
2729        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
2730                finderArgs, this);
2731
2732        if (count == null) {
2733            Session session = null;
2734
2735            try {
2736                session = openSession();
2737
2738                Query q = session.createQuery(
2739                        "SELECT COUNT(mbMessageFlag) FROM MBMessageFlag mbMessageFlag");
2740
2741                count = (Long)q.uniqueResult();
2742            }
2743            catch (Exception e) {
2744                throw processException(e);
2745            }
2746            finally {
2747                if (count == null) {
2748                    count = Long.valueOf(0);
2749                }
2750
2751                FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
2752                    count);
2753
2754                closeSession(session);
2755            }
2756        }
2757
2758        return count.intValue();
2759    }
2760
2761    public void afterPropertiesSet() {
2762        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
2763                    com.liferay.portal.util.PropsUtil.get(
2764                        "value.object.listener.com.liferay.portlet.messageboards.model.MBMessageFlag")));
2765
2766        if (listenerClassNames.length > 0) {
2767            try {
2768                List<ModelListener<MBMessageFlag>> listenersList = new ArrayList<ModelListener<MBMessageFlag>>();
2769
2770                for (String listenerClassName : listenerClassNames) {
2771                    listenersList.add((ModelListener<MBMessageFlag>)Class.forName(
2772                            listenerClassName).newInstance());
2773                }
2774
2775                listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
2776            }
2777            catch (Exception e) {
2778                _log.error(e);
2779            }
2780        }
2781    }
2782
2783    @BeanReference(name = "com.liferay.portlet.messageboards.service.persistence.MBBanPersistence.impl")
2784    protected com.liferay.portlet.messageboards.service.persistence.MBBanPersistence mbBanPersistence;
2785    @BeanReference(name = "com.liferay.portlet.messageboards.service.persistence.MBCategoryPersistence.impl")
2786    protected com.liferay.portlet.messageboards.service.persistence.MBCategoryPersistence mbCategoryPersistence;
2787    @BeanReference(name = "com.liferay.portlet.messageboards.service.persistence.MBDiscussionPersistence.impl")
2788    protected com.liferay.portlet.messageboards.service.persistence.MBDiscussionPersistence mbDiscussionPersistence;
2789    @BeanReference(name = "com.liferay.portlet.messageboards.service.persistence.MBMessagePersistence.impl")
2790    protected com.liferay.portlet.messageboards.service.persistence.MBMessagePersistence mbMessagePersistence;
2791    @BeanReference(name = "com.liferay.portlet.messageboards.service.persistence.MBMessageFlagPersistence.impl")
2792    protected com.liferay.portlet.messageboards.service.persistence.MBMessageFlagPersistence mbMessageFlagPersistence;
2793    @BeanReference(name = "com.liferay.portlet.messageboards.service.persistence.MBStatsUserPersistence.impl")
2794    protected com.liferay.portlet.messageboards.service.persistence.MBStatsUserPersistence mbStatsUserPersistence;
2795    @BeanReference(name = "com.liferay.portlet.messageboards.service.persistence.MBThreadPersistence.impl")
2796    protected com.liferay.portlet.messageboards.service.persistence.MBThreadPersistence mbThreadPersistence;
2797    @BeanReference(name = "com.liferay.portal.service.persistence.UserPersistence.impl")
2798    protected com.liferay.portal.service.persistence.UserPersistence userPersistence;
2799    private static Log _log = LogFactoryUtil.getLog(MBMessageFlagPersistenceImpl.class);
2800}