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