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