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