1   /**
2    * Copyright (c) 2000-2009 Liferay, Inc. All rights reserved.
3    *
4    * The contents of this file are subject to the terms of the Liferay Enterprise
5    * Subscription License ("License"). You may not use this file except in
6    * compliance with the License. You can obtain a copy of the License by
7    * contacting Liferay, Inc. See the License for the specific language governing
8    * permissions and limitations under the License, including but not limited to
9    * distribution rights of the Software.
10   *
11   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
12   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
13   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
14   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
15   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
16   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
17   * SOFTWARE.
18   */
19  
20  package com.liferay.portal.service.persistence;
21  
22  import com.liferay.portal.NoSuchSubscriptionException;
23  import com.liferay.portal.SystemException;
24  import com.liferay.portal.kernel.annotation.BeanReference;
25  import com.liferay.portal.kernel.cache.CacheRegistry;
26  import com.liferay.portal.kernel.dao.orm.DynamicQuery;
27  import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
28  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
29  import com.liferay.portal.kernel.dao.orm.FinderPath;
30  import com.liferay.portal.kernel.dao.orm.Query;
31  import com.liferay.portal.kernel.dao.orm.QueryPos;
32  import com.liferay.portal.kernel.dao.orm.QueryUtil;
33  import com.liferay.portal.kernel.dao.orm.Session;
34  import com.liferay.portal.kernel.log.Log;
35  import com.liferay.portal.kernel.log.LogFactoryUtil;
36  import com.liferay.portal.kernel.util.GetterUtil;
37  import com.liferay.portal.kernel.util.OrderByComparator;
38  import com.liferay.portal.kernel.util.StringPool;
39  import com.liferay.portal.kernel.util.StringUtil;
40  import com.liferay.portal.model.ModelListener;
41  import com.liferay.portal.model.Subscription;
42  import com.liferay.portal.model.impl.SubscriptionImpl;
43  import com.liferay.portal.model.impl.SubscriptionModelImpl;
44  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
45  
46  import java.util.ArrayList;
47  import java.util.Collections;
48  import java.util.List;
49  
50  /**
51   * <a href="SubscriptionPersistenceImpl.java.html"><b><i>View Source</i></b></a>
52   *
53   * @author Brian Wing Shun Chan
54   *
55   */
56  public class SubscriptionPersistenceImpl extends BasePersistenceImpl
57      implements SubscriptionPersistence {
58      public static final String FINDER_CLASS_NAME_ENTITY = SubscriptionImpl.class.getName();
59      public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
60          ".List";
61      public static final FinderPath FINDER_PATH_FIND_BY_USERID = new FinderPath(SubscriptionModelImpl.ENTITY_CACHE_ENABLED,
62              SubscriptionModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
63              "findByUserId", new String[] { Long.class.getName() });
64      public static final FinderPath FINDER_PATH_FIND_BY_OBC_USERID = new FinderPath(SubscriptionModelImpl.ENTITY_CACHE_ENABLED,
65              SubscriptionModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
66              "findByUserId",
67              new String[] {
68                  Long.class.getName(),
69                  
70              "java.lang.Integer", "java.lang.Integer",
71                  "com.liferay.portal.kernel.util.OrderByComparator"
72              });
73      public static final FinderPath FINDER_PATH_COUNT_BY_USERID = new FinderPath(SubscriptionModelImpl.ENTITY_CACHE_ENABLED,
74              SubscriptionModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
75              "countByUserId", new String[] { Long.class.getName() });
76      public static final FinderPath FINDER_PATH_FIND_BY_U_C = new FinderPath(SubscriptionModelImpl.ENTITY_CACHE_ENABLED,
77              SubscriptionModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
78              "findByU_C",
79              new String[] { Long.class.getName(), Long.class.getName() });
80      public static final FinderPath FINDER_PATH_FIND_BY_OBC_U_C = new FinderPath(SubscriptionModelImpl.ENTITY_CACHE_ENABLED,
81              SubscriptionModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
82              "findByU_C",
83              new String[] {
84                  Long.class.getName(), Long.class.getName(),
85                  
86              "java.lang.Integer", "java.lang.Integer",
87                  "com.liferay.portal.kernel.util.OrderByComparator"
88              });
89      public static final FinderPath FINDER_PATH_COUNT_BY_U_C = new FinderPath(SubscriptionModelImpl.ENTITY_CACHE_ENABLED,
90              SubscriptionModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
91              "countByU_C",
92              new String[] { Long.class.getName(), Long.class.getName() });
93      public static final FinderPath FINDER_PATH_FIND_BY_C_C_C = new FinderPath(SubscriptionModelImpl.ENTITY_CACHE_ENABLED,
94              SubscriptionModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
95              "findByC_C_C",
96              new String[] {
97                  Long.class.getName(), Long.class.getName(), Long.class.getName()
98              });
99      public static final FinderPath FINDER_PATH_FIND_BY_OBC_C_C_C = new FinderPath(SubscriptionModelImpl.ENTITY_CACHE_ENABLED,
100             SubscriptionModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
101             "findByC_C_C",
102             new String[] {
103                 Long.class.getName(), Long.class.getName(), Long.class.getName(),
104                 
105             "java.lang.Integer", "java.lang.Integer",
106                 "com.liferay.portal.kernel.util.OrderByComparator"
107             });
108     public static final FinderPath FINDER_PATH_COUNT_BY_C_C_C = new FinderPath(SubscriptionModelImpl.ENTITY_CACHE_ENABLED,
109             SubscriptionModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
110             "countByC_C_C",
111             new String[] {
112                 Long.class.getName(), Long.class.getName(), Long.class.getName()
113             });
114     public static final FinderPath FINDER_PATH_FETCH_BY_C_U_C_C = new FinderPath(SubscriptionModelImpl.ENTITY_CACHE_ENABLED,
115             SubscriptionModelImpl.FINDER_CACHE_ENABLED,
116             FINDER_CLASS_NAME_ENTITY, "fetchByC_U_C_C",
117             new String[] {
118                 Long.class.getName(), Long.class.getName(), Long.class.getName(),
119                 Long.class.getName()
120             });
121     public static final FinderPath FINDER_PATH_COUNT_BY_C_U_C_C = new FinderPath(SubscriptionModelImpl.ENTITY_CACHE_ENABLED,
122             SubscriptionModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
123             "countByC_U_C_C",
124             new String[] {
125                 Long.class.getName(), Long.class.getName(), Long.class.getName(),
126                 Long.class.getName()
127             });
128     public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(SubscriptionModelImpl.ENTITY_CACHE_ENABLED,
129             SubscriptionModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
130             "findAll", new String[0]);
131     public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(SubscriptionModelImpl.ENTITY_CACHE_ENABLED,
132             SubscriptionModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
133             "countAll", new String[0]);
134 
135     public void cacheResult(Subscription subscription) {
136         EntityCacheUtil.putResult(SubscriptionModelImpl.ENTITY_CACHE_ENABLED,
137             SubscriptionImpl.class, subscription.getPrimaryKey(), subscription);
138 
139         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_U_C_C,
140             new Object[] {
141                 new Long(subscription.getCompanyId()),
142                 new Long(subscription.getUserId()),
143                 new Long(subscription.getClassNameId()),
144                 new Long(subscription.getClassPK())
145             }, subscription);
146     }
147 
148     public void cacheResult(List<Subscription> subscriptions) {
149         for (Subscription subscription : subscriptions) {
150             if (EntityCacheUtil.getResult(
151                         SubscriptionModelImpl.ENTITY_CACHE_ENABLED,
152                         SubscriptionImpl.class, subscription.getPrimaryKey(),
153                         this) == null) {
154                 cacheResult(subscription);
155             }
156         }
157     }
158 
159     public void clearCache() {
160         CacheRegistry.clear(SubscriptionImpl.class.getName());
161         EntityCacheUtil.clearCache(SubscriptionImpl.class.getName());
162         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
163         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
164     }
165 
166     public Subscription create(long subscriptionId) {
167         Subscription subscription = new SubscriptionImpl();
168 
169         subscription.setNew(true);
170         subscription.setPrimaryKey(subscriptionId);
171 
172         return subscription;
173     }
174 
175     public Subscription remove(long subscriptionId)
176         throws NoSuchSubscriptionException, SystemException {
177         Session session = null;
178 
179         try {
180             session = openSession();
181 
182             Subscription subscription = (Subscription)session.get(SubscriptionImpl.class,
183                     new Long(subscriptionId));
184 
185             if (subscription == null) {
186                 if (_log.isWarnEnabled()) {
187                     _log.warn("No Subscription exists with the primary key " +
188                         subscriptionId);
189                 }
190 
191                 throw new NoSuchSubscriptionException(
192                     "No Subscription exists with the primary key " +
193                     subscriptionId);
194             }
195 
196             return remove(subscription);
197         }
198         catch (NoSuchSubscriptionException nsee) {
199             throw nsee;
200         }
201         catch (Exception e) {
202             throw processException(e);
203         }
204         finally {
205             closeSession(session);
206         }
207     }
208 
209     public Subscription remove(Subscription subscription)
210         throws SystemException {
211         for (ModelListener<Subscription> listener : listeners) {
212             listener.onBeforeRemove(subscription);
213         }
214 
215         subscription = removeImpl(subscription);
216 
217         for (ModelListener<Subscription> listener : listeners) {
218             listener.onAfterRemove(subscription);
219         }
220 
221         return subscription;
222     }
223 
224     protected Subscription removeImpl(Subscription subscription)
225         throws SystemException {
226         Session session = null;
227 
228         try {
229             session = openSession();
230 
231             if (subscription.isCachedModel() || BatchSessionUtil.isEnabled()) {
232                 Object staleObject = session.get(SubscriptionImpl.class,
233                         subscription.getPrimaryKeyObj());
234 
235                 if (staleObject != null) {
236                     session.evict(staleObject);
237                 }
238             }
239 
240             session.delete(subscription);
241 
242             session.flush();
243         }
244         catch (Exception e) {
245             throw processException(e);
246         }
247         finally {
248             closeSession(session);
249         }
250 
251         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
252 
253         SubscriptionModelImpl subscriptionModelImpl = (SubscriptionModelImpl)subscription;
254 
255         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_U_C_C,
256             new Object[] {
257                 new Long(subscriptionModelImpl.getOriginalCompanyId()),
258                 new Long(subscriptionModelImpl.getOriginalUserId()),
259                 new Long(subscriptionModelImpl.getOriginalClassNameId()),
260                 new Long(subscriptionModelImpl.getOriginalClassPK())
261             });
262 
263         EntityCacheUtil.removeResult(SubscriptionModelImpl.ENTITY_CACHE_ENABLED,
264             SubscriptionImpl.class, subscription.getPrimaryKey());
265 
266         return subscription;
267     }
268 
269     /**
270      * @deprecated Use <code>update(Subscription subscription, boolean merge)</code>.
271      */
272     public Subscription update(Subscription subscription)
273         throws SystemException {
274         if (_log.isWarnEnabled()) {
275             _log.warn(
276                 "Using the deprecated update(Subscription subscription) method. Use update(Subscription subscription, boolean merge) instead.");
277         }
278 
279         return update(subscription, false);
280     }
281 
282     /**
283      * Add, update, or merge, the entity. This method also calls the model
284      * listeners to trigger the proper events associated with adding, deleting,
285      * or updating an entity.
286      *
287      * @param        subscription the entity to add, update, or merge
288      * @param        merge boolean value for whether to merge the entity. The
289      *                default value is false. Setting merge to true is more
290      *                expensive and should only be true when subscription is
291      *                transient. See LEP-5473 for a detailed discussion of this
292      *                method.
293      * @return        true if the portlet can be displayed via Ajax
294      */
295     public Subscription update(Subscription subscription, boolean merge)
296         throws SystemException {
297         boolean isNew = subscription.isNew();
298 
299         for (ModelListener<Subscription> listener : listeners) {
300             if (isNew) {
301                 listener.onBeforeCreate(subscription);
302             }
303             else {
304                 listener.onBeforeUpdate(subscription);
305             }
306         }
307 
308         subscription = updateImpl(subscription, merge);
309 
310         for (ModelListener<Subscription> listener : listeners) {
311             if (isNew) {
312                 listener.onAfterCreate(subscription);
313             }
314             else {
315                 listener.onAfterUpdate(subscription);
316             }
317         }
318 
319         return subscription;
320     }
321 
322     public Subscription updateImpl(
323         com.liferay.portal.model.Subscription subscription, boolean merge)
324         throws SystemException {
325         boolean isNew = subscription.isNew();
326 
327         SubscriptionModelImpl subscriptionModelImpl = (SubscriptionModelImpl)subscription;
328 
329         Session session = null;
330 
331         try {
332             session = openSession();
333 
334             BatchSessionUtil.update(session, subscription, merge);
335 
336             subscription.setNew(false);
337         }
338         catch (Exception e) {
339             throw processException(e);
340         }
341         finally {
342             closeSession(session);
343         }
344 
345         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
346 
347         EntityCacheUtil.putResult(SubscriptionModelImpl.ENTITY_CACHE_ENABLED,
348             SubscriptionImpl.class, subscription.getPrimaryKey(), subscription);
349 
350         if (!isNew &&
351                 ((subscription.getCompanyId() != subscriptionModelImpl.getOriginalCompanyId()) ||
352                 (subscription.getUserId() != subscriptionModelImpl.getOriginalUserId()) ||
353                 (subscription.getClassNameId() != subscriptionModelImpl.getOriginalClassNameId()) ||
354                 (subscription.getClassPK() != subscriptionModelImpl.getOriginalClassPK()))) {
355             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_U_C_C,
356                 new Object[] {
357                     new Long(subscriptionModelImpl.getOriginalCompanyId()),
358                     new Long(subscriptionModelImpl.getOriginalUserId()),
359                     new Long(subscriptionModelImpl.getOriginalClassNameId()),
360                     new Long(subscriptionModelImpl.getOriginalClassPK())
361                 });
362         }
363 
364         if (isNew ||
365                 ((subscription.getCompanyId() != subscriptionModelImpl.getOriginalCompanyId()) ||
366                 (subscription.getUserId() != subscriptionModelImpl.getOriginalUserId()) ||
367                 (subscription.getClassNameId() != subscriptionModelImpl.getOriginalClassNameId()) ||
368                 (subscription.getClassPK() != subscriptionModelImpl.getOriginalClassPK()))) {
369             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_U_C_C,
370                 new Object[] {
371                     new Long(subscription.getCompanyId()),
372                     new Long(subscription.getUserId()),
373                     new Long(subscription.getClassNameId()),
374                     new Long(subscription.getClassPK())
375                 }, subscription);
376         }
377 
378         return subscription;
379     }
380 
381     public Subscription findByPrimaryKey(long subscriptionId)
382         throws NoSuchSubscriptionException, SystemException {
383         Subscription subscription = fetchByPrimaryKey(subscriptionId);
384 
385         if (subscription == null) {
386             if (_log.isWarnEnabled()) {
387                 _log.warn("No Subscription exists with the primary key " +
388                     subscriptionId);
389             }
390 
391             throw new NoSuchSubscriptionException(
392                 "No Subscription exists with the primary key " +
393                 subscriptionId);
394         }
395 
396         return subscription;
397     }
398 
399     public Subscription fetchByPrimaryKey(long subscriptionId)
400         throws SystemException {
401         Subscription subscription = (Subscription)EntityCacheUtil.getResult(SubscriptionModelImpl.ENTITY_CACHE_ENABLED,
402                 SubscriptionImpl.class, subscriptionId, this);
403 
404         if (subscription == null) {
405             Session session = null;
406 
407             try {
408                 session = openSession();
409 
410                 subscription = (Subscription)session.get(SubscriptionImpl.class,
411                         new Long(subscriptionId));
412             }
413             catch (Exception e) {
414                 throw processException(e);
415             }
416             finally {
417                 if (subscription != null) {
418                     cacheResult(subscription);
419                 }
420 
421                 closeSession(session);
422             }
423         }
424 
425         return subscription;
426     }
427 
428     public List<Subscription> findByUserId(long userId)
429         throws SystemException {
430         Object[] finderArgs = new Object[] { new Long(userId) };
431 
432         List<Subscription> list = (List<Subscription>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_USERID,
433                 finderArgs, this);
434 
435         if (list == null) {
436             Session session = null;
437 
438             try {
439                 session = openSession();
440 
441                 StringBuilder query = new StringBuilder();
442 
443                 query.append(
444                     "SELECT subscription FROM Subscription subscription WHERE ");
445 
446                 query.append("subscription.userId = ?");
447 
448                 query.append(" ");
449 
450                 Query q = session.createQuery(query.toString());
451 
452                 QueryPos qPos = QueryPos.getInstance(q);
453 
454                 qPos.add(userId);
455 
456                 list = q.list();
457             }
458             catch (Exception e) {
459                 throw processException(e);
460             }
461             finally {
462                 if (list == null) {
463                     list = new ArrayList<Subscription>();
464                 }
465 
466                 cacheResult(list);
467 
468                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_USERID,
469                     finderArgs, list);
470 
471                 closeSession(session);
472             }
473         }
474 
475         return list;
476     }
477 
478     public List<Subscription> findByUserId(long userId, int start, int end)
479         throws SystemException {
480         return findByUserId(userId, start, end, null);
481     }
482 
483     public List<Subscription> findByUserId(long userId, int start, int end,
484         OrderByComparator obc) throws SystemException {
485         Object[] finderArgs = new Object[] {
486                 new Long(userId),
487                 
488                 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
489             };
490 
491         List<Subscription> list = (List<Subscription>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_USERID,
492                 finderArgs, this);
493 
494         if (list == null) {
495             Session session = null;
496 
497             try {
498                 session = openSession();
499 
500                 StringBuilder query = new StringBuilder();
501 
502                 query.append(
503                     "SELECT subscription FROM Subscription subscription WHERE ");
504 
505                 query.append("subscription.userId = ?");
506 
507                 query.append(" ");
508 
509                 if (obc != null) {
510                     query.append("ORDER BY ");
511 
512                     String[] orderByFields = obc.getOrderByFields();
513 
514                     for (int i = 0; i < orderByFields.length; i++) {
515                         query.append("subscription.");
516                         query.append(orderByFields[i]);
517 
518                         if (obc.isAscending()) {
519                             query.append(" ASC");
520                         }
521                         else {
522                             query.append(" DESC");
523                         }
524 
525                         if ((i + 1) < orderByFields.length) {
526                             query.append(", ");
527                         }
528                     }
529                 }
530 
531                 Query q = session.createQuery(query.toString());
532 
533                 QueryPos qPos = QueryPos.getInstance(q);
534 
535                 qPos.add(userId);
536 
537                 list = (List<Subscription>)QueryUtil.list(q, getDialect(),
538                         start, end);
539             }
540             catch (Exception e) {
541                 throw processException(e);
542             }
543             finally {
544                 if (list == null) {
545                     list = new ArrayList<Subscription>();
546                 }
547 
548                 cacheResult(list);
549 
550                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_USERID,
551                     finderArgs, list);
552 
553                 closeSession(session);
554             }
555         }
556 
557         return list;
558     }
559 
560     public Subscription findByUserId_First(long userId, OrderByComparator obc)
561         throws NoSuchSubscriptionException, SystemException {
562         List<Subscription> list = findByUserId(userId, 0, 1, obc);
563 
564         if (list.isEmpty()) {
565             StringBuilder msg = new StringBuilder();
566 
567             msg.append("No Subscription exists with the key {");
568 
569             msg.append("userId=" + userId);
570 
571             msg.append(StringPool.CLOSE_CURLY_BRACE);
572 
573             throw new NoSuchSubscriptionException(msg.toString());
574         }
575         else {
576             return list.get(0);
577         }
578     }
579 
580     public Subscription findByUserId_Last(long userId, OrderByComparator obc)
581         throws NoSuchSubscriptionException, SystemException {
582         int count = countByUserId(userId);
583 
584         List<Subscription> list = findByUserId(userId, count - 1, count, obc);
585 
586         if (list.isEmpty()) {
587             StringBuilder msg = new StringBuilder();
588 
589             msg.append("No Subscription exists with the key {");
590 
591             msg.append("userId=" + userId);
592 
593             msg.append(StringPool.CLOSE_CURLY_BRACE);
594 
595             throw new NoSuchSubscriptionException(msg.toString());
596         }
597         else {
598             return list.get(0);
599         }
600     }
601 
602     public Subscription[] findByUserId_PrevAndNext(long subscriptionId,
603         long userId, OrderByComparator obc)
604         throws NoSuchSubscriptionException, SystemException {
605         Subscription subscription = findByPrimaryKey(subscriptionId);
606 
607         int count = countByUserId(userId);
608 
609         Session session = null;
610 
611         try {
612             session = openSession();
613 
614             StringBuilder query = new StringBuilder();
615 
616             query.append(
617                 "SELECT subscription FROM Subscription subscription WHERE ");
618 
619             query.append("subscription.userId = ?");
620 
621             query.append(" ");
622 
623             if (obc != null) {
624                 query.append("ORDER BY ");
625 
626                 String[] orderByFields = obc.getOrderByFields();
627 
628                 for (int i = 0; i < orderByFields.length; i++) {
629                     query.append("subscription.");
630                     query.append(orderByFields[i]);
631 
632                     if (obc.isAscending()) {
633                         query.append(" ASC");
634                     }
635                     else {
636                         query.append(" DESC");
637                     }
638 
639                     if ((i + 1) < orderByFields.length) {
640                         query.append(", ");
641                     }
642                 }
643             }
644 
645             Query q = session.createQuery(query.toString());
646 
647             QueryPos qPos = QueryPos.getInstance(q);
648 
649             qPos.add(userId);
650 
651             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
652                     subscription);
653 
654             Subscription[] array = new SubscriptionImpl[3];
655 
656             array[0] = (Subscription)objArray[0];
657             array[1] = (Subscription)objArray[1];
658             array[2] = (Subscription)objArray[2];
659 
660             return array;
661         }
662         catch (Exception e) {
663             throw processException(e);
664         }
665         finally {
666             closeSession(session);
667         }
668     }
669 
670     public List<Subscription> findByU_C(long userId, long classNameId)
671         throws SystemException {
672         Object[] finderArgs = new Object[] {
673                 new Long(userId), new Long(classNameId)
674             };
675 
676         List<Subscription> list = (List<Subscription>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_U_C,
677                 finderArgs, this);
678 
679         if (list == null) {
680             Session session = null;
681 
682             try {
683                 session = openSession();
684 
685                 StringBuilder query = new StringBuilder();
686 
687                 query.append(
688                     "SELECT subscription FROM Subscription subscription WHERE ");
689 
690                 query.append("subscription.userId = ?");
691 
692                 query.append(" AND ");
693 
694                 query.append("subscription.classNameId = ?");
695 
696                 query.append(" ");
697 
698                 Query q = session.createQuery(query.toString());
699 
700                 QueryPos qPos = QueryPos.getInstance(q);
701 
702                 qPos.add(userId);
703 
704                 qPos.add(classNameId);
705 
706                 list = q.list();
707             }
708             catch (Exception e) {
709                 throw processException(e);
710             }
711             finally {
712                 if (list == null) {
713                     list = new ArrayList<Subscription>();
714                 }
715 
716                 cacheResult(list);
717 
718                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_U_C, finderArgs,
719                     list);
720 
721                 closeSession(session);
722             }
723         }
724 
725         return list;
726     }
727 
728     public List<Subscription> findByU_C(long userId, long classNameId,
729         int start, int end) throws SystemException {
730         return findByU_C(userId, classNameId, start, end, null);
731     }
732 
733     public List<Subscription> findByU_C(long userId, long classNameId,
734         int start, int end, OrderByComparator obc) throws SystemException {
735         Object[] finderArgs = new Object[] {
736                 new Long(userId), new Long(classNameId),
737                 
738                 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
739             };
740 
741         List<Subscription> list = (List<Subscription>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_U_C,
742                 finderArgs, this);
743 
744         if (list == null) {
745             Session session = null;
746 
747             try {
748                 session = openSession();
749 
750                 StringBuilder query = new StringBuilder();
751 
752                 query.append(
753                     "SELECT subscription FROM Subscription subscription WHERE ");
754 
755                 query.append("subscription.userId = ?");
756 
757                 query.append(" AND ");
758 
759                 query.append("subscription.classNameId = ?");
760 
761                 query.append(" ");
762 
763                 if (obc != null) {
764                     query.append("ORDER BY ");
765 
766                     String[] orderByFields = obc.getOrderByFields();
767 
768                     for (int i = 0; i < orderByFields.length; i++) {
769                         query.append("subscription.");
770                         query.append(orderByFields[i]);
771 
772                         if (obc.isAscending()) {
773                             query.append(" ASC");
774                         }
775                         else {
776                             query.append(" DESC");
777                         }
778 
779                         if ((i + 1) < orderByFields.length) {
780                             query.append(", ");
781                         }
782                     }
783                 }
784 
785                 Query q = session.createQuery(query.toString());
786 
787                 QueryPos qPos = QueryPos.getInstance(q);
788 
789                 qPos.add(userId);
790 
791                 qPos.add(classNameId);
792 
793                 list = (List<Subscription>)QueryUtil.list(q, getDialect(),
794                         start, end);
795             }
796             catch (Exception e) {
797                 throw processException(e);
798             }
799             finally {
800                 if (list == null) {
801                     list = new ArrayList<Subscription>();
802                 }
803 
804                 cacheResult(list);
805 
806                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_U_C,
807                     finderArgs, list);
808 
809                 closeSession(session);
810             }
811         }
812 
813         return list;
814     }
815 
816     public Subscription findByU_C_First(long userId, long classNameId,
817         OrderByComparator obc)
818         throws NoSuchSubscriptionException, SystemException {
819         List<Subscription> list = findByU_C(userId, classNameId, 0, 1, obc);
820 
821         if (list.isEmpty()) {
822             StringBuilder msg = new StringBuilder();
823 
824             msg.append("No Subscription exists with the key {");
825 
826             msg.append("userId=" + userId);
827 
828             msg.append(", ");
829             msg.append("classNameId=" + classNameId);
830 
831             msg.append(StringPool.CLOSE_CURLY_BRACE);
832 
833             throw new NoSuchSubscriptionException(msg.toString());
834         }
835         else {
836             return list.get(0);
837         }
838     }
839 
840     public Subscription findByU_C_Last(long userId, long classNameId,
841         OrderByComparator obc)
842         throws NoSuchSubscriptionException, SystemException {
843         int count = countByU_C(userId, classNameId);
844 
845         List<Subscription> list = findByU_C(userId, classNameId, count - 1,
846                 count, obc);
847 
848         if (list.isEmpty()) {
849             StringBuilder msg = new StringBuilder();
850 
851             msg.append("No Subscription exists with the key {");
852 
853             msg.append("userId=" + userId);
854 
855             msg.append(", ");
856             msg.append("classNameId=" + classNameId);
857 
858             msg.append(StringPool.CLOSE_CURLY_BRACE);
859 
860             throw new NoSuchSubscriptionException(msg.toString());
861         }
862         else {
863             return list.get(0);
864         }
865     }
866 
867     public Subscription[] findByU_C_PrevAndNext(long subscriptionId,
868         long userId, long classNameId, OrderByComparator obc)
869         throws NoSuchSubscriptionException, SystemException {
870         Subscription subscription = findByPrimaryKey(subscriptionId);
871 
872         int count = countByU_C(userId, classNameId);
873 
874         Session session = null;
875 
876         try {
877             session = openSession();
878 
879             StringBuilder query = new StringBuilder();
880 
881             query.append(
882                 "SELECT subscription FROM Subscription subscription WHERE ");
883 
884             query.append("subscription.userId = ?");
885 
886             query.append(" AND ");
887 
888             query.append("subscription.classNameId = ?");
889 
890             query.append(" ");
891 
892             if (obc != null) {
893                 query.append("ORDER BY ");
894 
895                 String[] orderByFields = obc.getOrderByFields();
896 
897                 for (int i = 0; i < orderByFields.length; i++) {
898                     query.append("subscription.");
899                     query.append(orderByFields[i]);
900 
901                     if (obc.isAscending()) {
902                         query.append(" ASC");
903                     }
904                     else {
905                         query.append(" DESC");
906                     }
907 
908                     if ((i + 1) < orderByFields.length) {
909                         query.append(", ");
910                     }
911                 }
912             }
913 
914             Query q = session.createQuery(query.toString());
915 
916             QueryPos qPos = QueryPos.getInstance(q);
917 
918             qPos.add(userId);
919 
920             qPos.add(classNameId);
921 
922             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
923                     subscription);
924 
925             Subscription[] array = new SubscriptionImpl[3];
926 
927             array[0] = (Subscription)objArray[0];
928             array[1] = (Subscription)objArray[1];
929             array[2] = (Subscription)objArray[2];
930 
931             return array;
932         }
933         catch (Exception e) {
934             throw processException(e);
935         }
936         finally {
937             closeSession(session);
938         }
939     }
940 
941     public List<Subscription> findByC_C_C(long companyId, long classNameId,
942         long classPK) throws SystemException {
943         Object[] finderArgs = new Object[] {
944                 new Long(companyId), new Long(classNameId), new Long(classPK)
945             };
946 
947         List<Subscription> list = (List<Subscription>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_C_C_C,
948                 finderArgs, this);
949 
950         if (list == null) {
951             Session session = null;
952 
953             try {
954                 session = openSession();
955 
956                 StringBuilder query = new StringBuilder();
957 
958                 query.append(
959                     "SELECT subscription FROM Subscription subscription WHERE ");
960 
961                 query.append("subscription.companyId = ?");
962 
963                 query.append(" AND ");
964 
965                 query.append("subscription.classNameId = ?");
966 
967                 query.append(" AND ");
968 
969                 query.append("subscription.classPK = ?");
970 
971                 query.append(" ");
972 
973                 Query q = session.createQuery(query.toString());
974 
975                 QueryPos qPos = QueryPos.getInstance(q);
976 
977                 qPos.add(companyId);
978 
979                 qPos.add(classNameId);
980 
981                 qPos.add(classPK);
982 
983                 list = q.list();
984             }
985             catch (Exception e) {
986                 throw processException(e);
987             }
988             finally {
989                 if (list == null) {
990                     list = new ArrayList<Subscription>();
991                 }
992 
993                 cacheResult(list);
994 
995                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_C_C_C,
996                     finderArgs, list);
997 
998                 closeSession(session);
999             }
1000        }
1001
1002        return list;
1003    }
1004
1005    public List<Subscription> findByC_C_C(long companyId, long classNameId,
1006        long classPK, int start, int end) throws SystemException {
1007        return findByC_C_C(companyId, classNameId, classPK, start, end, null);
1008    }
1009
1010    public List<Subscription> findByC_C_C(long companyId, long classNameId,
1011        long classPK, int start, int end, OrderByComparator obc)
1012        throws SystemException {
1013        Object[] finderArgs = new Object[] {
1014                new Long(companyId), new Long(classNameId), new Long(classPK),
1015                
1016                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1017            };
1018
1019        List<Subscription> list = (List<Subscription>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_OBC_C_C_C,
1020                finderArgs, this);
1021
1022        if (list == null) {
1023            Session session = null;
1024
1025            try {
1026                session = openSession();
1027
1028                StringBuilder query = new StringBuilder();
1029
1030                query.append(
1031                    "SELECT subscription FROM Subscription subscription WHERE ");
1032
1033                query.append("subscription.companyId = ?");
1034
1035                query.append(" AND ");
1036
1037                query.append("subscription.classNameId = ?");
1038
1039                query.append(" AND ");
1040
1041                query.append("subscription.classPK = ?");
1042
1043                query.append(" ");
1044
1045                if (obc != null) {
1046                    query.append("ORDER BY ");
1047
1048                    String[] orderByFields = obc.getOrderByFields();
1049
1050                    for (int i = 0; i < orderByFields.length; i++) {
1051                        query.append("subscription.");
1052                        query.append(orderByFields[i]);
1053
1054                        if (obc.isAscending()) {
1055                            query.append(" ASC");
1056                        }
1057                        else {
1058                            query.append(" DESC");
1059                        }
1060
1061                        if ((i + 1) < orderByFields.length) {
1062                            query.append(", ");
1063                        }
1064                    }
1065                }
1066
1067                Query q = session.createQuery(query.toString());
1068
1069                QueryPos qPos = QueryPos.getInstance(q);
1070
1071                qPos.add(companyId);
1072
1073                qPos.add(classNameId);
1074
1075                qPos.add(classPK);
1076
1077                list = (List<Subscription>)QueryUtil.list(q, getDialect(),
1078                        start, end);
1079            }
1080            catch (Exception e) {
1081                throw processException(e);
1082            }
1083            finally {
1084                if (list == null) {
1085                    list = new ArrayList<Subscription>();
1086                }
1087
1088                cacheResult(list);
1089
1090                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_OBC_C_C_C,
1091                    finderArgs, list);
1092
1093                closeSession(session);
1094            }
1095        }
1096
1097        return list;
1098    }
1099
1100    public Subscription findByC_C_C_First(long companyId, long classNameId,
1101        long classPK, OrderByComparator obc)
1102        throws NoSuchSubscriptionException, SystemException {
1103        List<Subscription> list = findByC_C_C(companyId, classNameId, classPK,
1104                0, 1, obc);
1105
1106        if (list.isEmpty()) {
1107            StringBuilder msg = new StringBuilder();
1108
1109            msg.append("No Subscription exists with the key {");
1110
1111            msg.append("companyId=" + companyId);
1112
1113            msg.append(", ");
1114            msg.append("classNameId=" + classNameId);
1115
1116            msg.append(", ");
1117            msg.append("classPK=" + classPK);
1118
1119            msg.append(StringPool.CLOSE_CURLY_BRACE);
1120
1121            throw new NoSuchSubscriptionException(msg.toString());
1122        }
1123        else {
1124            return list.get(0);
1125        }
1126    }
1127
1128    public Subscription findByC_C_C_Last(long companyId, long classNameId,
1129        long classPK, OrderByComparator obc)
1130        throws NoSuchSubscriptionException, SystemException {
1131        int count = countByC_C_C(companyId, classNameId, classPK);
1132
1133        List<Subscription> list = findByC_C_C(companyId, classNameId, classPK,
1134                count - 1, count, obc);
1135
1136        if (list.isEmpty()) {
1137            StringBuilder msg = new StringBuilder();
1138
1139            msg.append("No Subscription exists with the key {");
1140
1141            msg.append("companyId=" + companyId);
1142
1143            msg.append(", ");
1144            msg.append("classNameId=" + classNameId);
1145
1146            msg.append(", ");
1147            msg.append("classPK=" + classPK);
1148
1149            msg.append(StringPool.CLOSE_CURLY_BRACE);
1150
1151            throw new NoSuchSubscriptionException(msg.toString());
1152        }
1153        else {
1154            return list.get(0);
1155        }
1156    }
1157
1158    public Subscription[] findByC_C_C_PrevAndNext(long subscriptionId,
1159        long companyId, long classNameId, long classPK, OrderByComparator obc)
1160        throws NoSuchSubscriptionException, SystemException {
1161        Subscription subscription = findByPrimaryKey(subscriptionId);
1162
1163        int count = countByC_C_C(companyId, classNameId, classPK);
1164
1165        Session session = null;
1166
1167        try {
1168            session = openSession();
1169
1170            StringBuilder query = new StringBuilder();
1171
1172            query.append(
1173                "SELECT subscription FROM Subscription subscription WHERE ");
1174
1175            query.append("subscription.companyId = ?");
1176
1177            query.append(" AND ");
1178
1179            query.append("subscription.classNameId = ?");
1180
1181            query.append(" AND ");
1182
1183            query.append("subscription.classPK = ?");
1184
1185            query.append(" ");
1186
1187            if (obc != null) {
1188                query.append("ORDER BY ");
1189
1190                String[] orderByFields = obc.getOrderByFields();
1191
1192                for (int i = 0; i < orderByFields.length; i++) {
1193                    query.append("subscription.");
1194                    query.append(orderByFields[i]);
1195
1196                    if (obc.isAscending()) {
1197                        query.append(" ASC");
1198                    }
1199                    else {
1200                        query.append(" DESC");
1201                    }
1202
1203                    if ((i + 1) < orderByFields.length) {
1204                        query.append(", ");
1205                    }
1206                }
1207            }
1208
1209            Query q = session.createQuery(query.toString());
1210
1211            QueryPos qPos = QueryPos.getInstance(q);
1212
1213            qPos.add(companyId);
1214
1215            qPos.add(classNameId);
1216
1217            qPos.add(classPK);
1218
1219            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1220                    subscription);
1221
1222            Subscription[] array = new SubscriptionImpl[3];
1223
1224            array[0] = (Subscription)objArray[0];
1225            array[1] = (Subscription)objArray[1];
1226            array[2] = (Subscription)objArray[2];
1227
1228            return array;
1229        }
1230        catch (Exception e) {
1231            throw processException(e);
1232        }
1233        finally {
1234            closeSession(session);
1235        }
1236    }
1237
1238    public Subscription findByC_U_C_C(long companyId, long userId,
1239        long classNameId, long classPK)
1240        throws NoSuchSubscriptionException, SystemException {
1241        Subscription subscription = fetchByC_U_C_C(companyId, userId,
1242                classNameId, classPK);
1243
1244        if (subscription == null) {
1245            StringBuilder msg = new StringBuilder();
1246
1247            msg.append("No Subscription exists with the key {");
1248
1249            msg.append("companyId=" + companyId);
1250
1251            msg.append(", ");
1252            msg.append("userId=" + userId);
1253
1254            msg.append(", ");
1255            msg.append("classNameId=" + classNameId);
1256
1257            msg.append(", ");
1258            msg.append("classPK=" + classPK);
1259
1260            msg.append(StringPool.CLOSE_CURLY_BRACE);
1261
1262            if (_log.isWarnEnabled()) {
1263                _log.warn(msg.toString());
1264            }
1265
1266            throw new NoSuchSubscriptionException(msg.toString());
1267        }
1268
1269        return subscription;
1270    }
1271
1272    public Subscription fetchByC_U_C_C(long companyId, long userId,
1273        long classNameId, long classPK) throws SystemException {
1274        return fetchByC_U_C_C(companyId, userId, classNameId, classPK, true);
1275    }
1276
1277    public Subscription fetchByC_U_C_C(long companyId, long userId,
1278        long classNameId, long classPK, boolean retrieveFromCache)
1279        throws SystemException {
1280        Object[] finderArgs = new Object[] {
1281                new Long(companyId), new Long(userId), new Long(classNameId),
1282                new Long(classPK)
1283            };
1284
1285        Object result = null;
1286
1287        if (retrieveFromCache) {
1288            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_C_U_C_C,
1289                    finderArgs, this);
1290        }
1291
1292        if (result == null) {
1293            Session session = null;
1294
1295            try {
1296                session = openSession();
1297
1298                StringBuilder query = new StringBuilder();
1299
1300                query.append(
1301                    "SELECT subscription FROM Subscription subscription WHERE ");
1302
1303                query.append("subscription.companyId = ?");
1304
1305                query.append(" AND ");
1306
1307                query.append("subscription.userId = ?");
1308
1309                query.append(" AND ");
1310
1311                query.append("subscription.classNameId = ?");
1312
1313                query.append(" AND ");
1314
1315                query.append("subscription.classPK = ?");
1316
1317                query.append(" ");
1318
1319                Query q = session.createQuery(query.toString());
1320
1321                QueryPos qPos = QueryPos.getInstance(q);
1322
1323                qPos.add(companyId);
1324
1325                qPos.add(userId);
1326
1327                qPos.add(classNameId);
1328
1329                qPos.add(classPK);
1330
1331                List<Subscription> list = q.list();
1332
1333                result = list;
1334
1335                Subscription subscription = null;
1336
1337                if (list.isEmpty()) {
1338                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_U_C_C,
1339                        finderArgs, list);
1340                }
1341                else {
1342                    subscription = list.get(0);
1343
1344                    cacheResult(subscription);
1345
1346                    if ((subscription.getCompanyId() != companyId) ||
1347                            (subscription.getUserId() != userId) ||
1348                            (subscription.getClassNameId() != classNameId) ||
1349                            (subscription.getClassPK() != classPK)) {
1350                        FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_U_C_C,
1351                            finderArgs, subscription);
1352                    }
1353                }
1354
1355                return subscription;
1356            }
1357            catch (Exception e) {
1358                throw processException(e);
1359            }
1360            finally {
1361                if (result == null) {
1362                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_U_C_C,
1363                        finderArgs, new ArrayList<Subscription>());
1364                }
1365
1366                closeSession(session);
1367            }
1368        }
1369        else {
1370            if (result instanceof List) {
1371                return null;
1372            }
1373            else {
1374                return (Subscription)result;
1375            }
1376        }
1377    }
1378
1379    public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery)
1380        throws SystemException {
1381        Session session = null;
1382
1383        try {
1384            session = openSession();
1385
1386            dynamicQuery.compile(session);
1387
1388            return dynamicQuery.list();
1389        }
1390        catch (Exception e) {
1391            throw processException(e);
1392        }
1393        finally {
1394            closeSession(session);
1395        }
1396    }
1397
1398    public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery,
1399        int start, int end) throws SystemException {
1400        Session session = null;
1401
1402        try {
1403            session = openSession();
1404
1405            dynamicQuery.setLimit(start, end);
1406
1407            dynamicQuery.compile(session);
1408
1409            return dynamicQuery.list();
1410        }
1411        catch (Exception e) {
1412            throw processException(e);
1413        }
1414        finally {
1415            closeSession(session);
1416        }
1417    }
1418
1419    public List<Subscription> findAll() throws SystemException {
1420        return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1421    }
1422
1423    public List<Subscription> findAll(int start, int end)
1424        throws SystemException {
1425        return findAll(start, end, null);
1426    }
1427
1428    public List<Subscription> findAll(int start, int end, OrderByComparator obc)
1429        throws SystemException {
1430        Object[] finderArgs = new Object[] {
1431                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1432            };
1433
1434        List<Subscription> list = (List<Subscription>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
1435                finderArgs, this);
1436
1437        if (list == null) {
1438            Session session = null;
1439
1440            try {
1441                session = openSession();
1442
1443                StringBuilder query = new StringBuilder();
1444
1445                query.append(
1446                    "SELECT subscription FROM Subscription subscription ");
1447
1448                if (obc != null) {
1449                    query.append("ORDER BY ");
1450
1451                    String[] orderByFields = obc.getOrderByFields();
1452
1453                    for (int i = 0; i < orderByFields.length; i++) {
1454                        query.append("subscription.");
1455                        query.append(orderByFields[i]);
1456
1457                        if (obc.isAscending()) {
1458                            query.append(" ASC");
1459                        }
1460                        else {
1461                            query.append(" DESC");
1462                        }
1463
1464                        if ((i + 1) < orderByFields.length) {
1465                            query.append(", ");
1466                        }
1467                    }
1468                }
1469
1470                Query q = session.createQuery(query.toString());
1471
1472                if (obc == null) {
1473                    list = (List<Subscription>)QueryUtil.list(q, getDialect(),
1474                            start, end, false);
1475
1476                    Collections.sort(list);
1477                }
1478                else {
1479                    list = (List<Subscription>)QueryUtil.list(q, getDialect(),
1480                            start, end);
1481                }
1482            }
1483            catch (Exception e) {
1484                throw processException(e);
1485            }
1486            finally {
1487                if (list == null) {
1488                    list = new ArrayList<Subscription>();
1489                }
1490
1491                cacheResult(list);
1492
1493                FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
1494
1495                closeSession(session);
1496            }
1497        }
1498
1499        return list;
1500    }
1501
1502    public void removeByUserId(long userId) throws SystemException {
1503        for (Subscription subscription : findByUserId(userId)) {
1504            remove(subscription);
1505        }
1506    }
1507
1508    public void removeByU_C(long userId, long classNameId)
1509        throws SystemException {
1510        for (Subscription subscription : findByU_C(userId, classNameId)) {
1511            remove(subscription);
1512        }
1513    }
1514
1515    public void removeByC_C_C(long companyId, long classNameId, long classPK)
1516        throws SystemException {
1517        for (Subscription subscription : findByC_C_C(companyId, classNameId,
1518                classPK)) {
1519            remove(subscription);
1520        }
1521    }
1522
1523    public void removeByC_U_C_C(long companyId, long userId, long classNameId,
1524        long classPK) throws NoSuchSubscriptionException, SystemException {
1525        Subscription subscription = findByC_U_C_C(companyId, userId,
1526                classNameId, classPK);
1527
1528        remove(subscription);
1529    }
1530
1531    public void removeAll() throws SystemException {
1532        for (Subscription subscription : findAll()) {
1533            remove(subscription);
1534        }
1535    }
1536
1537    public int countByUserId(long userId) throws SystemException {
1538        Object[] finderArgs = new Object[] { new Long(userId) };
1539
1540        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_USERID,
1541                finderArgs, this);
1542
1543        if (count == null) {
1544            Session session = null;
1545
1546            try {
1547                session = openSession();
1548
1549                StringBuilder query = new StringBuilder();
1550
1551                query.append("SELECT COUNT(subscription) ");
1552                query.append("FROM Subscription subscription WHERE ");
1553
1554                query.append("subscription.userId = ?");
1555
1556                query.append(" ");
1557
1558                Query q = session.createQuery(query.toString());
1559
1560                QueryPos qPos = QueryPos.getInstance(q);
1561
1562                qPos.add(userId);
1563
1564                count = (Long)q.uniqueResult();
1565            }
1566            catch (Exception e) {
1567                throw processException(e);
1568            }
1569            finally {
1570                if (count == null) {
1571                    count = Long.valueOf(0);
1572                }
1573
1574                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_USERID,
1575                    finderArgs, count);
1576
1577                closeSession(session);
1578            }
1579        }
1580
1581        return count.intValue();
1582    }
1583
1584    public int countByU_C(long userId, long classNameId)
1585        throws SystemException {
1586        Object[] finderArgs = new Object[] {
1587                new Long(userId), new Long(classNameId)
1588            };
1589
1590        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_U_C,
1591                finderArgs, this);
1592
1593        if (count == null) {
1594            Session session = null;
1595
1596            try {
1597                session = openSession();
1598
1599                StringBuilder query = new StringBuilder();
1600
1601                query.append("SELECT COUNT(subscription) ");
1602                query.append("FROM Subscription subscription WHERE ");
1603
1604                query.append("subscription.userId = ?");
1605
1606                query.append(" AND ");
1607
1608                query.append("subscription.classNameId = ?");
1609
1610                query.append(" ");
1611
1612                Query q = session.createQuery(query.toString());
1613
1614                QueryPos qPos = QueryPos.getInstance(q);
1615
1616                qPos.add(userId);
1617
1618                qPos.add(classNameId);
1619
1620                count = (Long)q.uniqueResult();
1621            }
1622            catch (Exception e) {
1623                throw processException(e);
1624            }
1625            finally {
1626                if (count == null) {
1627                    count = Long.valueOf(0);
1628                }
1629
1630                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_U_C, finderArgs,
1631                    count);
1632
1633                closeSession(session);
1634            }
1635        }
1636
1637        return count.intValue();
1638    }
1639
1640    public int countByC_C_C(long companyId, long classNameId, long classPK)
1641        throws SystemException {
1642        Object[] finderArgs = new Object[] {
1643                new Long(companyId), new Long(classNameId), new Long(classPK)
1644            };
1645
1646        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_C_C,
1647                finderArgs, this);
1648
1649        if (count == null) {
1650            Session session = null;
1651
1652            try {
1653                session = openSession();
1654
1655                StringBuilder query = new StringBuilder();
1656
1657                query.append("SELECT COUNT(subscription) ");
1658                query.append("FROM Subscription subscription WHERE ");
1659
1660                query.append("subscription.companyId = ?");
1661
1662                query.append(" AND ");
1663
1664                query.append("subscription.classNameId = ?");
1665
1666                query.append(" AND ");
1667
1668                query.append("subscription.classPK = ?");
1669
1670                query.append(" ");
1671
1672                Query q = session.createQuery(query.toString());
1673
1674                QueryPos qPos = QueryPos.getInstance(q);
1675
1676                qPos.add(companyId);
1677
1678                qPos.add(classNameId);
1679
1680                qPos.add(classPK);
1681
1682                count = (Long)q.uniqueResult();
1683            }
1684            catch (Exception e) {
1685                throw processException(e);
1686            }
1687            finally {
1688                if (count == null) {
1689                    count = Long.valueOf(0);
1690                }
1691
1692                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_C_C,
1693                    finderArgs, count);
1694
1695                closeSession(session);
1696            }
1697        }
1698
1699        return count.intValue();
1700    }
1701
1702    public int countByC_U_C_C(long companyId, long userId, long classNameId,
1703        long classPK) throws SystemException {
1704        Object[] finderArgs = new Object[] {
1705                new Long(companyId), new Long(userId), new Long(classNameId),
1706                new Long(classPK)
1707            };
1708
1709        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_U_C_C,
1710                finderArgs, this);
1711
1712        if (count == null) {
1713            Session session = null;
1714
1715            try {
1716                session = openSession();
1717
1718                StringBuilder query = new StringBuilder();
1719
1720                query.append("SELECT COUNT(subscription) ");
1721                query.append("FROM Subscription subscription WHERE ");
1722
1723                query.append("subscription.companyId = ?");
1724
1725                query.append(" AND ");
1726
1727                query.append("subscription.userId = ?");
1728
1729                query.append(" AND ");
1730
1731                query.append("subscription.classNameId = ?");
1732
1733                query.append(" AND ");
1734
1735                query.append("subscription.classPK = ?");
1736
1737                query.append(" ");
1738
1739                Query q = session.createQuery(query.toString());
1740
1741                QueryPos qPos = QueryPos.getInstance(q);
1742
1743                qPos.add(companyId);
1744
1745                qPos.add(userId);
1746
1747                qPos.add(classNameId);
1748
1749                qPos.add(classPK);
1750
1751                count = (Long)q.uniqueResult();
1752            }
1753            catch (Exception e) {
1754                throw processException(e);
1755            }
1756            finally {
1757                if (count == null) {
1758                    count = Long.valueOf(0);
1759                }
1760
1761                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_U_C_C,
1762                    finderArgs, count);
1763
1764                closeSession(session);
1765            }
1766        }
1767
1768        return count.intValue();
1769    }
1770
1771    public int countAll() throws SystemException {
1772        Object[] finderArgs = new Object[0];
1773
1774        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
1775                finderArgs, this);
1776
1777        if (count == null) {
1778            Session session = null;
1779
1780            try {
1781                session = openSession();
1782
1783                Query q = session.createQuery(
1784                        "SELECT COUNT(subscription) FROM Subscription subscription");
1785
1786                count = (Long)q.uniqueResult();
1787            }
1788            catch (Exception e) {
1789                throw processException(e);
1790            }
1791            finally {
1792                if (count == null) {
1793                    count = Long.valueOf(0);
1794                }
1795
1796                FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
1797                    count);
1798
1799                closeSession(session);
1800            }
1801        }
1802
1803        return count.intValue();
1804    }
1805
1806    public void afterPropertiesSet() {
1807        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
1808                    com.liferay.portal.util.PropsUtil.get(
1809                        "value.object.listener.com.liferay.portal.model.Subscription")));
1810
1811        if (listenerClassNames.length > 0) {
1812            try {
1813                List<ModelListener<Subscription>> listenersList = new ArrayList<ModelListener<Subscription>>();
1814
1815                for (String listenerClassName : listenerClassNames) {
1816                    listenersList.add((ModelListener<Subscription>)Class.forName(
1817                            listenerClassName).newInstance());
1818                }
1819
1820                listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
1821            }
1822            catch (Exception e) {
1823                _log.error(e);
1824            }
1825        }
1826    }
1827
1828    @BeanReference(name = "com.liferay.portal.service.persistence.AccountPersistence.impl")
1829    protected com.liferay.portal.service.persistence.AccountPersistence accountPersistence;
1830    @BeanReference(name = "com.liferay.portal.service.persistence.AddressPersistence.impl")
1831    protected com.liferay.portal.service.persistence.AddressPersistence addressPersistence;
1832    @BeanReference(name = "com.liferay.portal.service.persistence.BrowserTrackerPersistence.impl")
1833    protected com.liferay.portal.service.persistence.BrowserTrackerPersistence browserTrackerPersistence;
1834    @BeanReference(name = "com.liferay.portal.service.persistence.ClassNamePersistence.impl")
1835    protected com.liferay.portal.service.persistence.ClassNamePersistence classNamePersistence;
1836    @BeanReference(name = "com.liferay.portal.service.persistence.CompanyPersistence.impl")
1837    protected com.liferay.portal.service.persistence.CompanyPersistence companyPersistence;
1838    @BeanReference(name = "com.liferay.portal.service.persistence.ContactPersistence.impl")
1839    protected com.liferay.portal.service.persistence.ContactPersistence contactPersistence;
1840    @BeanReference(name = "com.liferay.portal.service.persistence.CountryPersistence.impl")
1841    protected com.liferay.portal.service.persistence.CountryPersistence countryPersistence;
1842    @BeanReference(name = "com.liferay.portal.service.persistence.EmailAddressPersistence.impl")
1843    protected com.liferay.portal.service.persistence.EmailAddressPersistence emailAddressPersistence;
1844    @BeanReference(name = "com.liferay.portal.service.persistence.GroupPersistence.impl")
1845    protected com.liferay.portal.service.persistence.GroupPersistence groupPersistence;
1846    @BeanReference(name = "com.liferay.portal.service.persistence.ImagePersistence.impl")
1847    protected com.liferay.portal.service.persistence.ImagePersistence imagePersistence;
1848    @BeanReference(name = "com.liferay.portal.service.persistence.LayoutPersistence.impl")
1849    protected com.liferay.portal.service.persistence.LayoutPersistence layoutPersistence;
1850    @BeanReference(name = "com.liferay.portal.service.persistence.LayoutSetPersistence.impl")
1851    protected com.liferay.portal.service.persistence.LayoutSetPersistence layoutSetPersistence;
1852    @BeanReference(name = "com.liferay.portal.service.persistence.ListTypePersistence.impl")
1853    protected com.liferay.portal.service.persistence.ListTypePersistence listTypePersistence;
1854    @BeanReference(name = "com.liferay.portal.service.persistence.MembershipRequestPersistence.impl")
1855    protected com.liferay.portal.service.persistence.MembershipRequestPersistence membershipRequestPersistence;
1856    @BeanReference(name = "com.liferay.portal.service.persistence.OrganizationPersistence.impl")
1857    protected com.liferay.portal.service.persistence.OrganizationPersistence organizationPersistence;
1858    @BeanReference(name = "com.liferay.portal.service.persistence.OrgGroupPermissionPersistence.impl")
1859    protected com.liferay.portal.service.persistence.OrgGroupPermissionPersistence orgGroupPermissionPersistence;
1860    @BeanReference(name = "com.liferay.portal.service.persistence.OrgGroupRolePersistence.impl")
1861    protected com.liferay.portal.service.persistence.OrgGroupRolePersistence orgGroupRolePersistence;
1862    @BeanReference(name = "com.liferay.portal.service.persistence.OrgLaborPersistence.impl")
1863    protected com.liferay.portal.service.persistence.OrgLaborPersistence orgLaborPersistence;
1864    @BeanReference(name = "com.liferay.portal.service.persistence.PasswordPolicyPersistence.impl")
1865    protected com.liferay.portal.service.persistence.PasswordPolicyPersistence passwordPolicyPersistence;
1866    @BeanReference(name = "com.liferay.portal.service.persistence.PasswordPolicyRelPersistence.impl")
1867    protected com.liferay.portal.service.persistence.PasswordPolicyRelPersistence passwordPolicyRelPersistence;
1868    @BeanReference(name = "com.liferay.portal.service.persistence.PasswordTrackerPersistence.impl")
1869    protected com.liferay.portal.service.persistence.PasswordTrackerPersistence passwordTrackerPersistence;
1870    @BeanReference(name = "com.liferay.portal.service.persistence.PermissionPersistence.impl")
1871    protected com.liferay.portal.service.persistence.PermissionPersistence permissionPersistence;
1872    @BeanReference(name = "com.liferay.portal.service.persistence.PhonePersistence.impl")
1873    protected com.liferay.portal.service.persistence.PhonePersistence phonePersistence;
1874    @BeanReference(name = "com.liferay.portal.service.persistence.PluginSettingPersistence.impl")
1875    protected com.liferay.portal.service.persistence.PluginSettingPersistence pluginSettingPersistence;
1876    @BeanReference(name = "com.liferay.portal.service.persistence.PortletPersistence.impl")
1877    protected com.liferay.portal.service.persistence.PortletPersistence portletPersistence;
1878    @BeanReference(name = "com.liferay.portal.service.persistence.PortletItemPersistence.impl")
1879    protected com.liferay.portal.service.persistence.PortletItemPersistence portletItemPersistence;
1880    @BeanReference(name = "com.liferay.portal.service.persistence.PortletPreferencesPersistence.impl")
1881    protected com.liferay.portal.service.persistence.PortletPreferencesPersistence portletPreferencesPersistence;
1882    @BeanReference(name = "com.liferay.portal.service.persistence.RegionPersistence.impl")
1883    protected com.liferay.portal.service.persistence.RegionPersistence regionPersistence;
1884    @BeanReference(name = "com.liferay.portal.service.persistence.ReleasePersistence.impl")
1885    protected com.liferay.portal.service.persistence.ReleasePersistence releasePersistence;
1886    @BeanReference(name = "com.liferay.portal.service.persistence.ResourcePersistence.impl")
1887    protected com.liferay.portal.service.persistence.ResourcePersistence resourcePersistence;
1888    @BeanReference(name = "com.liferay.portal.service.persistence.ResourceActionPersistence.impl")
1889    protected com.liferay.portal.service.persistence.ResourceActionPersistence resourceActionPersistence;
1890    @BeanReference(name = "com.liferay.portal.service.persistence.ResourceCodePersistence.impl")
1891    protected com.liferay.portal.service.persistence.ResourceCodePersistence resourceCodePersistence;
1892    @BeanReference(name = "com.liferay.portal.service.persistence.ResourcePermissionPersistence.impl")
1893    protected com.liferay.portal.service.persistence.ResourcePermissionPersistence resourcePermissionPersistence;
1894    @BeanReference(name = "com.liferay.portal.service.persistence.RolePersistence.impl")
1895    protected com.liferay.portal.service.persistence.RolePersistence rolePersistence;
1896    @BeanReference(name = "com.liferay.portal.service.persistence.ServiceComponentPersistence.impl")
1897    protected com.liferay.portal.service.persistence.ServiceComponentPersistence serviceComponentPersistence;
1898    @BeanReference(name = "com.liferay.portal.service.persistence.ShardPersistence.impl")
1899    protected com.liferay.portal.service.persistence.ShardPersistence shardPersistence;
1900    @BeanReference(name = "com.liferay.portal.service.persistence.SubscriptionPersistence.impl")
1901    protected com.liferay.portal.service.persistence.SubscriptionPersistence subscriptionPersistence;
1902    @BeanReference(name = "com.liferay.portal.service.persistence.UserPersistence.impl")
1903    protected com.liferay.portal.service.persistence.UserPersistence userPersistence;
1904    @BeanReference(name = "com.liferay.portal.service.persistence.UserGroupPersistence.impl")
1905    protected com.liferay.portal.service.persistence.UserGroupPersistence userGroupPersistence;
1906    @BeanReference(name = "com.liferay.portal.service.persistence.UserGroupRolePersistence.impl")
1907    protected com.liferay.portal.service.persistence.UserGroupRolePersistence userGroupRolePersistence;
1908    @BeanReference(name = "com.liferay.portal.service.persistence.UserIdMapperPersistence.impl")
1909    protected com.liferay.portal.service.persistence.UserIdMapperPersistence userIdMapperPersistence;
1910    @BeanReference(name = "com.liferay.portal.service.persistence.UserTrackerPersistence.impl")
1911    protected com.liferay.portal.service.persistence.UserTrackerPersistence userTrackerPersistence;
1912    @BeanReference(name = "com.liferay.portal.service.persistence.UserTrackerPathPersistence.impl")
1913    protected com.liferay.portal.service.persistence.UserTrackerPathPersistence userTrackerPathPersistence;
1914    @BeanReference(name = "com.liferay.portal.service.persistence.WebDAVPropsPersistence.impl")
1915    protected com.liferay.portal.service.persistence.WebDAVPropsPersistence webDAVPropsPersistence;
1916    @BeanReference(name = "com.liferay.portal.service.persistence.WebsitePersistence.impl")
1917    protected com.liferay.portal.service.persistence.WebsitePersistence websitePersistence;
1918    private static Log _log = LogFactoryUtil.getLog(SubscriptionPersistenceImpl.class);
1919}