1   /**
2    * Copyright (c) 2000-2008 Liferay, Inc. All rights reserved.
3    *
4    * Permission is hereby granted, free of charge, to any person obtaining a copy
5    * of this software and associated documentation files (the "Software"), to deal
6    * in the Software without restriction, including without limitation the rights
7    * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8    * copies of the Software, and to permit persons to whom the Software is
9    * furnished to do so, subject to the following conditions:
10   *
11   * The above copyright notice and this permission notice shall be included in
12   * all copies or substantial portions of the Software.
13   *
14   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20   * SOFTWARE.
21   */
22  
23  package com.liferay.portal.service.persistence;
24  
25  import com.liferay.portal.NoSuchEmailAddressException;
26  import com.liferay.portal.SystemException;
27  import com.liferay.portal.kernel.bean.InitializingBean;
28  import com.liferay.portal.kernel.dao.orm.DynamicQuery;
29  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
30  import com.liferay.portal.kernel.dao.orm.Query;
31  import com.liferay.portal.kernel.dao.orm.QueryPos;
32  import com.liferay.portal.kernel.dao.orm.QueryUtil;
33  import com.liferay.portal.kernel.dao.orm.Session;
34  import com.liferay.portal.kernel.util.GetterUtil;
35  import com.liferay.portal.kernel.util.ListUtil;
36  import com.liferay.portal.kernel.util.OrderByComparator;
37  import com.liferay.portal.kernel.util.StringPool;
38  import com.liferay.portal.kernel.util.StringUtil;
39  import com.liferay.portal.model.EmailAddress;
40  import com.liferay.portal.model.ModelListener;
41  import com.liferay.portal.model.impl.EmailAddressImpl;
42  import com.liferay.portal.model.impl.EmailAddressModelImpl;
43  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
44  
45  import org.apache.commons.logging.Log;
46  import org.apache.commons.logging.LogFactory;
47  
48  import java.util.ArrayList;
49  import java.util.Collections;
50  import java.util.Iterator;
51  import java.util.List;
52  
53  /**
54   * <a href="EmailAddressPersistenceImpl.java.html"><b><i>View Source</i></b></a>
55   *
56   * @author Brian Wing Shun Chan
57   *
58   */
59  public class EmailAddressPersistenceImpl extends BasePersistenceImpl
60      implements EmailAddressPersistence, InitializingBean {
61      public EmailAddress create(long emailAddressId) {
62          EmailAddress emailAddress = new EmailAddressImpl();
63  
64          emailAddress.setNew(true);
65          emailAddress.setPrimaryKey(emailAddressId);
66  
67          return emailAddress;
68      }
69  
70      public EmailAddress remove(long emailAddressId)
71          throws NoSuchEmailAddressException, SystemException {
72          Session session = null;
73  
74          try {
75              session = openSession();
76  
77              EmailAddress emailAddress = (EmailAddress)session.get(EmailAddressImpl.class,
78                      new Long(emailAddressId));
79  
80              if (emailAddress == null) {
81                  if (_log.isWarnEnabled()) {
82                      _log.warn("No EmailAddress exists with the primary key " +
83                          emailAddressId);
84                  }
85  
86                  throw new NoSuchEmailAddressException(
87                      "No EmailAddress exists with the primary key " +
88                      emailAddressId);
89              }
90  
91              return remove(emailAddress);
92          }
93          catch (NoSuchEmailAddressException nsee) {
94              throw nsee;
95          }
96          catch (Exception e) {
97              throw processException(e);
98          }
99          finally {
100             closeSession(session);
101         }
102     }
103 
104     public EmailAddress remove(EmailAddress emailAddress)
105         throws SystemException {
106         if (_listeners.length > 0) {
107             for (ModelListener listener : _listeners) {
108                 listener.onBeforeRemove(emailAddress);
109             }
110         }
111 
112         emailAddress = removeImpl(emailAddress);
113 
114         if (_listeners.length > 0) {
115             for (ModelListener listener : _listeners) {
116                 listener.onAfterRemove(emailAddress);
117             }
118         }
119 
120         return emailAddress;
121     }
122 
123     protected EmailAddress removeImpl(EmailAddress emailAddress)
124         throws SystemException {
125         Session session = null;
126 
127         try {
128             session = openSession();
129 
130             session.delete(emailAddress);
131 
132             session.flush();
133 
134             return emailAddress;
135         }
136         catch (Exception e) {
137             throw processException(e);
138         }
139         finally {
140             closeSession(session);
141 
142             FinderCacheUtil.clearCache(EmailAddress.class.getName());
143         }
144     }
145 
146     /**
147      * @deprecated Use <code>update(EmailAddress emailAddress, boolean merge)</code>.
148      */
149     public EmailAddress update(EmailAddress emailAddress)
150         throws SystemException {
151         if (_log.isWarnEnabled()) {
152             _log.warn(
153                 "Using the deprecated update(EmailAddress emailAddress) method. Use update(EmailAddress emailAddress, boolean merge) instead.");
154         }
155 
156         return update(emailAddress, false);
157     }
158 
159     /**
160      * Add, update, or merge, the entity. This method also calls the model
161      * listeners to trigger the proper events associated with adding, deleting,
162      * or updating an entity.
163      *
164      * @param        emailAddress the entity to add, update, or merge
165      * @param        merge boolean value for whether to merge the entity. The
166      *                default value is false. Setting merge to true is more
167      *                expensive and should only be true when emailAddress is
168      *                transient. See LEP-5473 for a detailed discussion of this
169      *                method.
170      * @return        true if the portlet can be displayed via Ajax
171      */
172     public EmailAddress update(EmailAddress emailAddress, boolean merge)
173         throws SystemException {
174         boolean isNew = emailAddress.isNew();
175 
176         if (_listeners.length > 0) {
177             for (ModelListener listener : _listeners) {
178                 if (isNew) {
179                     listener.onBeforeCreate(emailAddress);
180                 }
181                 else {
182                     listener.onBeforeUpdate(emailAddress);
183                 }
184             }
185         }
186 
187         emailAddress = updateImpl(emailAddress, merge);
188 
189         if (_listeners.length > 0) {
190             for (ModelListener listener : _listeners) {
191                 if (isNew) {
192                     listener.onAfterCreate(emailAddress);
193                 }
194                 else {
195                     listener.onAfterUpdate(emailAddress);
196                 }
197             }
198         }
199 
200         return emailAddress;
201     }
202 
203     public EmailAddress updateImpl(
204         com.liferay.portal.model.EmailAddress emailAddress, boolean merge)
205         throws SystemException {
206         Session session = null;
207 
208         try {
209             session = openSession();
210 
211             if (merge) {
212                 session.merge(emailAddress);
213             }
214             else {
215                 if (emailAddress.isNew()) {
216                     session.save(emailAddress);
217                 }
218             }
219 
220             session.flush();
221 
222             emailAddress.setNew(false);
223 
224             return emailAddress;
225         }
226         catch (Exception e) {
227             throw processException(e);
228         }
229         finally {
230             closeSession(session);
231 
232             FinderCacheUtil.clearCache(EmailAddress.class.getName());
233         }
234     }
235 
236     public EmailAddress findByPrimaryKey(long emailAddressId)
237         throws NoSuchEmailAddressException, SystemException {
238         EmailAddress emailAddress = fetchByPrimaryKey(emailAddressId);
239 
240         if (emailAddress == null) {
241             if (_log.isWarnEnabled()) {
242                 _log.warn("No EmailAddress exists with the primary key " +
243                     emailAddressId);
244             }
245 
246             throw new NoSuchEmailAddressException(
247                 "No EmailAddress exists with the primary key " +
248                 emailAddressId);
249         }
250 
251         return emailAddress;
252     }
253 
254     public EmailAddress fetchByPrimaryKey(long emailAddressId)
255         throws SystemException {
256         Session session = null;
257 
258         try {
259             session = openSession();
260 
261             return (EmailAddress)session.get(EmailAddressImpl.class,
262                 new Long(emailAddressId));
263         }
264         catch (Exception e) {
265             throw processException(e);
266         }
267         finally {
268             closeSession(session);
269         }
270     }
271 
272     public List<EmailAddress> findByCompanyId(long companyId)
273         throws SystemException {
274         boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
275         String finderClassName = EmailAddress.class.getName();
276         String finderMethodName = "findByCompanyId";
277         String[] finderParams = new String[] { Long.class.getName() };
278         Object[] finderArgs = new Object[] { new Long(companyId) };
279 
280         Object result = null;
281 
282         if (finderClassNameCacheEnabled) {
283             result = FinderCacheUtil.getResult(finderClassName,
284                     finderMethodName, finderParams, finderArgs, this);
285         }
286 
287         if (result == null) {
288             Session session = null;
289 
290             try {
291                 session = openSession();
292 
293                 StringBuilder query = new StringBuilder();
294 
295                 query.append(
296                     "FROM com.liferay.portal.model.EmailAddress WHERE ");
297 
298                 query.append("companyId = ?");
299 
300                 query.append(" ");
301 
302                 query.append("ORDER BY ");
303 
304                 query.append("createDate ASC");
305 
306                 Query q = session.createQuery(query.toString());
307 
308                 QueryPos qPos = QueryPos.getInstance(q);
309 
310                 qPos.add(companyId);
311 
312                 List<EmailAddress> list = q.list();
313 
314                 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
315                     finderClassName, finderMethodName, finderParams,
316                     finderArgs, list);
317 
318                 return list;
319             }
320             catch (Exception e) {
321                 throw processException(e);
322             }
323             finally {
324                 closeSession(session);
325             }
326         }
327         else {
328             return (List<EmailAddress>)result;
329         }
330     }
331 
332     public List<EmailAddress> findByCompanyId(long companyId, int start, int end)
333         throws SystemException {
334         return findByCompanyId(companyId, start, end, null);
335     }
336 
337     public List<EmailAddress> findByCompanyId(long companyId, int start,
338         int end, OrderByComparator obc) throws SystemException {
339         boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
340         String finderClassName = EmailAddress.class.getName();
341         String finderMethodName = "findByCompanyId";
342         String[] finderParams = new String[] {
343                 Long.class.getName(),
344                 
345                 "java.lang.Integer", "java.lang.Integer",
346                 "com.liferay.portal.kernel.util.OrderByComparator"
347             };
348         Object[] finderArgs = new Object[] {
349                 new Long(companyId),
350                 
351                 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
352             };
353 
354         Object result = null;
355 
356         if (finderClassNameCacheEnabled) {
357             result = FinderCacheUtil.getResult(finderClassName,
358                     finderMethodName, finderParams, finderArgs, this);
359         }
360 
361         if (result == null) {
362             Session session = null;
363 
364             try {
365                 session = openSession();
366 
367                 StringBuilder query = new StringBuilder();
368 
369                 query.append(
370                     "FROM com.liferay.portal.model.EmailAddress WHERE ");
371 
372                 query.append("companyId = ?");
373 
374                 query.append(" ");
375 
376                 if (obc != null) {
377                     query.append("ORDER BY ");
378                     query.append(obc.getOrderBy());
379                 }
380 
381                 else {
382                     query.append("ORDER BY ");
383 
384                     query.append("createDate ASC");
385                 }
386 
387                 Query q = session.createQuery(query.toString());
388 
389                 QueryPos qPos = QueryPos.getInstance(q);
390 
391                 qPos.add(companyId);
392 
393                 List<EmailAddress> list = (List<EmailAddress>)QueryUtil.list(q,
394                         getDialect(), start, end);
395 
396                 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
397                     finderClassName, finderMethodName, finderParams,
398                     finderArgs, list);
399 
400                 return list;
401             }
402             catch (Exception e) {
403                 throw processException(e);
404             }
405             finally {
406                 closeSession(session);
407             }
408         }
409         else {
410             return (List<EmailAddress>)result;
411         }
412     }
413 
414     public EmailAddress findByCompanyId_First(long companyId,
415         OrderByComparator obc)
416         throws NoSuchEmailAddressException, SystemException {
417         List<EmailAddress> list = findByCompanyId(companyId, 0, 1, obc);
418 
419         if (list.size() == 0) {
420             StringBuilder msg = new StringBuilder();
421 
422             msg.append("No EmailAddress exists with the key {");
423 
424             msg.append("companyId=" + companyId);
425 
426             msg.append(StringPool.CLOSE_CURLY_BRACE);
427 
428             throw new NoSuchEmailAddressException(msg.toString());
429         }
430         else {
431             return list.get(0);
432         }
433     }
434 
435     public EmailAddress findByCompanyId_Last(long companyId,
436         OrderByComparator obc)
437         throws NoSuchEmailAddressException, SystemException {
438         int count = countByCompanyId(companyId);
439 
440         List<EmailAddress> list = findByCompanyId(companyId, count - 1, count,
441                 obc);
442 
443         if (list.size() == 0) {
444             StringBuilder msg = new StringBuilder();
445 
446             msg.append("No EmailAddress exists with the key {");
447 
448             msg.append("companyId=" + companyId);
449 
450             msg.append(StringPool.CLOSE_CURLY_BRACE);
451 
452             throw new NoSuchEmailAddressException(msg.toString());
453         }
454         else {
455             return list.get(0);
456         }
457     }
458 
459     public EmailAddress[] findByCompanyId_PrevAndNext(long emailAddressId,
460         long companyId, OrderByComparator obc)
461         throws NoSuchEmailAddressException, SystemException {
462         EmailAddress emailAddress = findByPrimaryKey(emailAddressId);
463 
464         int count = countByCompanyId(companyId);
465 
466         Session session = null;
467 
468         try {
469             session = openSession();
470 
471             StringBuilder query = new StringBuilder();
472 
473             query.append("FROM com.liferay.portal.model.EmailAddress WHERE ");
474 
475             query.append("companyId = ?");
476 
477             query.append(" ");
478 
479             if (obc != null) {
480                 query.append("ORDER BY ");
481                 query.append(obc.getOrderBy());
482             }
483 
484             else {
485                 query.append("ORDER BY ");
486 
487                 query.append("createDate ASC");
488             }
489 
490             Query q = session.createQuery(query.toString());
491 
492             QueryPos qPos = QueryPos.getInstance(q);
493 
494             qPos.add(companyId);
495 
496             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
497                     emailAddress);
498 
499             EmailAddress[] array = new EmailAddressImpl[3];
500 
501             array[0] = (EmailAddress)objArray[0];
502             array[1] = (EmailAddress)objArray[1];
503             array[2] = (EmailAddress)objArray[2];
504 
505             return array;
506         }
507         catch (Exception e) {
508             throw processException(e);
509         }
510         finally {
511             closeSession(session);
512         }
513     }
514 
515     public List<EmailAddress> findByUserId(long userId)
516         throws SystemException {
517         boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
518         String finderClassName = EmailAddress.class.getName();
519         String finderMethodName = "findByUserId";
520         String[] finderParams = new String[] { Long.class.getName() };
521         Object[] finderArgs = new Object[] { new Long(userId) };
522 
523         Object result = null;
524 
525         if (finderClassNameCacheEnabled) {
526             result = FinderCacheUtil.getResult(finderClassName,
527                     finderMethodName, finderParams, finderArgs, this);
528         }
529 
530         if (result == null) {
531             Session session = null;
532 
533             try {
534                 session = openSession();
535 
536                 StringBuilder query = new StringBuilder();
537 
538                 query.append(
539                     "FROM com.liferay.portal.model.EmailAddress WHERE ");
540 
541                 query.append("userId = ?");
542 
543                 query.append(" ");
544 
545                 query.append("ORDER BY ");
546 
547                 query.append("createDate ASC");
548 
549                 Query q = session.createQuery(query.toString());
550 
551                 QueryPos qPos = QueryPos.getInstance(q);
552 
553                 qPos.add(userId);
554 
555                 List<EmailAddress> list = q.list();
556 
557                 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
558                     finderClassName, finderMethodName, finderParams,
559                     finderArgs, list);
560 
561                 return list;
562             }
563             catch (Exception e) {
564                 throw processException(e);
565             }
566             finally {
567                 closeSession(session);
568             }
569         }
570         else {
571             return (List<EmailAddress>)result;
572         }
573     }
574 
575     public List<EmailAddress> findByUserId(long userId, int start, int end)
576         throws SystemException {
577         return findByUserId(userId, start, end, null);
578     }
579 
580     public List<EmailAddress> findByUserId(long userId, int start, int end,
581         OrderByComparator obc) throws SystemException {
582         boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
583         String finderClassName = EmailAddress.class.getName();
584         String finderMethodName = "findByUserId";
585         String[] finderParams = new String[] {
586                 Long.class.getName(),
587                 
588                 "java.lang.Integer", "java.lang.Integer",
589                 "com.liferay.portal.kernel.util.OrderByComparator"
590             };
591         Object[] finderArgs = new Object[] {
592                 new Long(userId),
593                 
594                 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
595             };
596 
597         Object result = null;
598 
599         if (finderClassNameCacheEnabled) {
600             result = FinderCacheUtil.getResult(finderClassName,
601                     finderMethodName, finderParams, finderArgs, this);
602         }
603 
604         if (result == null) {
605             Session session = null;
606 
607             try {
608                 session = openSession();
609 
610                 StringBuilder query = new StringBuilder();
611 
612                 query.append(
613                     "FROM com.liferay.portal.model.EmailAddress WHERE ");
614 
615                 query.append("userId = ?");
616 
617                 query.append(" ");
618 
619                 if (obc != null) {
620                     query.append("ORDER BY ");
621                     query.append(obc.getOrderBy());
622                 }
623 
624                 else {
625                     query.append("ORDER BY ");
626 
627                     query.append("createDate ASC");
628                 }
629 
630                 Query q = session.createQuery(query.toString());
631 
632                 QueryPos qPos = QueryPos.getInstance(q);
633 
634                 qPos.add(userId);
635 
636                 List<EmailAddress> list = (List<EmailAddress>)QueryUtil.list(q,
637                         getDialect(), start, end);
638 
639                 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
640                     finderClassName, finderMethodName, finderParams,
641                     finderArgs, list);
642 
643                 return list;
644             }
645             catch (Exception e) {
646                 throw processException(e);
647             }
648             finally {
649                 closeSession(session);
650             }
651         }
652         else {
653             return (List<EmailAddress>)result;
654         }
655     }
656 
657     public EmailAddress findByUserId_First(long userId, OrderByComparator obc)
658         throws NoSuchEmailAddressException, SystemException {
659         List<EmailAddress> list = findByUserId(userId, 0, 1, obc);
660 
661         if (list.size() == 0) {
662             StringBuilder msg = new StringBuilder();
663 
664             msg.append("No EmailAddress exists with the key {");
665 
666             msg.append("userId=" + userId);
667 
668             msg.append(StringPool.CLOSE_CURLY_BRACE);
669 
670             throw new NoSuchEmailAddressException(msg.toString());
671         }
672         else {
673             return list.get(0);
674         }
675     }
676 
677     public EmailAddress findByUserId_Last(long userId, OrderByComparator obc)
678         throws NoSuchEmailAddressException, SystemException {
679         int count = countByUserId(userId);
680 
681         List<EmailAddress> list = findByUserId(userId, count - 1, count, obc);
682 
683         if (list.size() == 0) {
684             StringBuilder msg = new StringBuilder();
685 
686             msg.append("No EmailAddress exists with the key {");
687 
688             msg.append("userId=" + userId);
689 
690             msg.append(StringPool.CLOSE_CURLY_BRACE);
691 
692             throw new NoSuchEmailAddressException(msg.toString());
693         }
694         else {
695             return list.get(0);
696         }
697     }
698 
699     public EmailAddress[] findByUserId_PrevAndNext(long emailAddressId,
700         long userId, OrderByComparator obc)
701         throws NoSuchEmailAddressException, SystemException {
702         EmailAddress emailAddress = findByPrimaryKey(emailAddressId);
703 
704         int count = countByUserId(userId);
705 
706         Session session = null;
707 
708         try {
709             session = openSession();
710 
711             StringBuilder query = new StringBuilder();
712 
713             query.append("FROM com.liferay.portal.model.EmailAddress WHERE ");
714 
715             query.append("userId = ?");
716 
717             query.append(" ");
718 
719             if (obc != null) {
720                 query.append("ORDER BY ");
721                 query.append(obc.getOrderBy());
722             }
723 
724             else {
725                 query.append("ORDER BY ");
726 
727                 query.append("createDate ASC");
728             }
729 
730             Query q = session.createQuery(query.toString());
731 
732             QueryPos qPos = QueryPos.getInstance(q);
733 
734             qPos.add(userId);
735 
736             Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
737                     emailAddress);
738 
739             EmailAddress[] array = new EmailAddressImpl[3];
740 
741             array[0] = (EmailAddress)objArray[0];
742             array[1] = (EmailAddress)objArray[1];
743             array[2] = (EmailAddress)objArray[2];
744 
745             return array;
746         }
747         catch (Exception e) {
748             throw processException(e);
749         }
750         finally {
751             closeSession(session);
752         }
753     }
754 
755     public List<EmailAddress> findByC_C(long companyId, long classNameId)
756         throws SystemException {
757         boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
758         String finderClassName = EmailAddress.class.getName();
759         String finderMethodName = "findByC_C";
760         String[] finderParams = new String[] {
761                 Long.class.getName(), Long.class.getName()
762             };
763         Object[] finderArgs = new Object[] {
764                 new Long(companyId), new Long(classNameId)
765             };
766 
767         Object result = null;
768 
769         if (finderClassNameCacheEnabled) {
770             result = FinderCacheUtil.getResult(finderClassName,
771                     finderMethodName, finderParams, finderArgs, this);
772         }
773 
774         if (result == null) {
775             Session session = null;
776 
777             try {
778                 session = openSession();
779 
780                 StringBuilder query = new StringBuilder();
781 
782                 query.append(
783                     "FROM com.liferay.portal.model.EmailAddress WHERE ");
784 
785                 query.append("companyId = ?");
786 
787                 query.append(" AND ");
788 
789                 query.append("classNameId = ?");
790 
791                 query.append(" ");
792 
793                 query.append("ORDER BY ");
794 
795                 query.append("createDate ASC");
796 
797                 Query q = session.createQuery(query.toString());
798 
799                 QueryPos qPos = QueryPos.getInstance(q);
800 
801                 qPos.add(companyId);
802 
803                 qPos.add(classNameId);
804 
805                 List<EmailAddress> list = q.list();
806 
807                 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
808                     finderClassName, finderMethodName, finderParams,
809                     finderArgs, list);
810 
811                 return list;
812             }
813             catch (Exception e) {
814                 throw processException(e);
815             }
816             finally {
817                 closeSession(session);
818             }
819         }
820         else {
821             return (List<EmailAddress>)result;
822         }
823     }
824 
825     public List<EmailAddress> findByC_C(long companyId, long classNameId,
826         int start, int end) throws SystemException {
827         return findByC_C(companyId, classNameId, start, end, null);
828     }
829 
830     public List<EmailAddress> findByC_C(long companyId, long classNameId,
831         int start, int end, OrderByComparator obc) throws SystemException {
832         boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
833         String finderClassName = EmailAddress.class.getName();
834         String finderMethodName = "findByC_C";
835         String[] finderParams = new String[] {
836                 Long.class.getName(), Long.class.getName(),
837                 
838                 "java.lang.Integer", "java.lang.Integer",
839                 "com.liferay.portal.kernel.util.OrderByComparator"
840             };
841         Object[] finderArgs = new Object[] {
842                 new Long(companyId), new Long(classNameId),
843                 
844                 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
845             };
846 
847         Object result = null;
848 
849         if (finderClassNameCacheEnabled) {
850             result = FinderCacheUtil.getResult(finderClassName,
851                     finderMethodName, finderParams, finderArgs, this);
852         }
853 
854         if (result == null) {
855             Session session = null;
856 
857             try {
858                 session = openSession();
859 
860                 StringBuilder query = new StringBuilder();
861 
862                 query.append(
863                     "FROM com.liferay.portal.model.EmailAddress WHERE ");
864 
865                 query.append("companyId = ?");
866 
867                 query.append(" AND ");
868 
869                 query.append("classNameId = ?");
870 
871                 query.append(" ");
872 
873                 if (obc != null) {
874                     query.append("ORDER BY ");
875                     query.append(obc.getOrderBy());
876                 }
877 
878                 else {
879                     query.append("ORDER BY ");
880 
881                     query.append("createDate ASC");
882                 }
883 
884                 Query q = session.createQuery(query.toString());
885 
886                 QueryPos qPos = QueryPos.getInstance(q);
887 
888                 qPos.add(companyId);
889 
890                 qPos.add(classNameId);
891 
892                 List<EmailAddress> list = (List<EmailAddress>)QueryUtil.list(q,
893                         getDialect(), start, end);
894 
895                 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
896                     finderClassName, finderMethodName, finderParams,
897                     finderArgs, list);
898 
899                 return list;
900             }
901             catch (Exception e) {
902                 throw processException(e);
903             }
904             finally {
905                 closeSession(session);
906             }
907         }
908         else {
909             return (List<EmailAddress>)result;
910         }
911     }
912 
913     public EmailAddress findByC_C_First(long companyId, long classNameId,
914         OrderByComparator obc)
915         throws NoSuchEmailAddressException, SystemException {
916         List<EmailAddress> list = findByC_C(companyId, classNameId, 0, 1, obc);
917 
918         if (list.size() == 0) {
919             StringBuilder msg = new StringBuilder();
920 
921             msg.append("No EmailAddress exists with the key {");
922 
923             msg.append("companyId=" + companyId);
924 
925             msg.append(", ");
926             msg.append("classNameId=" + classNameId);
927 
928             msg.append(StringPool.CLOSE_CURLY_BRACE);
929 
930             throw new NoSuchEmailAddressException(msg.toString());
931         }
932         else {
933             return list.get(0);
934         }
935     }
936 
937     public EmailAddress findByC_C_Last(long companyId, long classNameId,
938         OrderByComparator obc)
939         throws NoSuchEmailAddressException, SystemException {
940         int count = countByC_C(companyId, classNameId);
941 
942         List<EmailAddress> list = findByC_C(companyId, classNameId, count - 1,
943                 count, obc);
944 
945         if (list.size() == 0) {
946             StringBuilder msg = new StringBuilder();
947 
948             msg.append("No EmailAddress exists with the key {");
949 
950             msg.append("companyId=" + companyId);
951 
952             msg.append(", ");
953             msg.append("classNameId=" + classNameId);
954 
955             msg.append(StringPool.CLOSE_CURLY_BRACE);
956 
957             throw new NoSuchEmailAddressException(msg.toString());
958         }
959         else {
960             return list.get(0);
961         }
962     }
963 
964     public EmailAddress[] findByC_C_PrevAndNext(long emailAddressId,
965         long companyId, long classNameId, OrderByComparator obc)
966         throws NoSuchEmailAddressException, SystemException {
967         EmailAddress emailAddress = findByPrimaryKey(emailAddressId);
968 
969         int count = countByC_C(companyId, classNameId);
970 
971         Session session = null;
972 
973         try {
974             session = openSession();
975 
976             StringBuilder query = new StringBuilder();
977 
978             query.append("FROM com.liferay.portal.model.EmailAddress WHERE ");
979 
980             query.append("companyId = ?");
981 
982             query.append(" AND ");
983 
984             query.append("classNameId = ?");
985 
986             query.append(" ");
987 
988             if (obc != null) {
989                 query.append("ORDER BY ");
990                 query.append(obc.getOrderBy());
991             }
992 
993             else {
994                 query.append("ORDER BY ");
995 
996                 query.append("createDate ASC");
997             }
998 
999             Query q = session.createQuery(query.toString());
1000
1001            QueryPos qPos = QueryPos.getInstance(q);
1002
1003            qPos.add(companyId);
1004
1005            qPos.add(classNameId);
1006
1007            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1008                    emailAddress);
1009
1010            EmailAddress[] array = new EmailAddressImpl[3];
1011
1012            array[0] = (EmailAddress)objArray[0];
1013            array[1] = (EmailAddress)objArray[1];
1014            array[2] = (EmailAddress)objArray[2];
1015
1016            return array;
1017        }
1018        catch (Exception e) {
1019            throw processException(e);
1020        }
1021        finally {
1022            closeSession(session);
1023        }
1024    }
1025
1026    public List<EmailAddress> findByC_C_C(long companyId, long classNameId,
1027        long classPK) throws SystemException {
1028        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
1029        String finderClassName = EmailAddress.class.getName();
1030        String finderMethodName = "findByC_C_C";
1031        String[] finderParams = new String[] {
1032                Long.class.getName(), Long.class.getName(), Long.class.getName()
1033            };
1034        Object[] finderArgs = new Object[] {
1035                new Long(companyId), new Long(classNameId), new Long(classPK)
1036            };
1037
1038        Object result = null;
1039
1040        if (finderClassNameCacheEnabled) {
1041            result = FinderCacheUtil.getResult(finderClassName,
1042                    finderMethodName, finderParams, finderArgs, this);
1043        }
1044
1045        if (result == null) {
1046            Session session = null;
1047
1048            try {
1049                session = openSession();
1050
1051                StringBuilder query = new StringBuilder();
1052
1053                query.append(
1054                    "FROM com.liferay.portal.model.EmailAddress WHERE ");
1055
1056                query.append("companyId = ?");
1057
1058                query.append(" AND ");
1059
1060                query.append("classNameId = ?");
1061
1062                query.append(" AND ");
1063
1064                query.append("classPK = ?");
1065
1066                query.append(" ");
1067
1068                query.append("ORDER BY ");
1069
1070                query.append("createDate ASC");
1071
1072                Query q = session.createQuery(query.toString());
1073
1074                QueryPos qPos = QueryPos.getInstance(q);
1075
1076                qPos.add(companyId);
1077
1078                qPos.add(classNameId);
1079
1080                qPos.add(classPK);
1081
1082                List<EmailAddress> list = q.list();
1083
1084                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1085                    finderClassName, finderMethodName, finderParams,
1086                    finderArgs, list);
1087
1088                return list;
1089            }
1090            catch (Exception e) {
1091                throw processException(e);
1092            }
1093            finally {
1094                closeSession(session);
1095            }
1096        }
1097        else {
1098            return (List<EmailAddress>)result;
1099        }
1100    }
1101
1102    public List<EmailAddress> findByC_C_C(long companyId, long classNameId,
1103        long classPK, int start, int end) throws SystemException {
1104        return findByC_C_C(companyId, classNameId, classPK, start, end, null);
1105    }
1106
1107    public List<EmailAddress> findByC_C_C(long companyId, long classNameId,
1108        long classPK, int start, int end, OrderByComparator obc)
1109        throws SystemException {
1110        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
1111        String finderClassName = EmailAddress.class.getName();
1112        String finderMethodName = "findByC_C_C";
1113        String[] finderParams = new String[] {
1114                Long.class.getName(), Long.class.getName(), Long.class.getName(),
1115                
1116                "java.lang.Integer", "java.lang.Integer",
1117                "com.liferay.portal.kernel.util.OrderByComparator"
1118            };
1119        Object[] finderArgs = new Object[] {
1120                new Long(companyId), new Long(classNameId), new Long(classPK),
1121                
1122                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1123            };
1124
1125        Object result = null;
1126
1127        if (finderClassNameCacheEnabled) {
1128            result = FinderCacheUtil.getResult(finderClassName,
1129                    finderMethodName, finderParams, finderArgs, this);
1130        }
1131
1132        if (result == null) {
1133            Session session = null;
1134
1135            try {
1136                session = openSession();
1137
1138                StringBuilder query = new StringBuilder();
1139
1140                query.append(
1141                    "FROM com.liferay.portal.model.EmailAddress WHERE ");
1142
1143                query.append("companyId = ?");
1144
1145                query.append(" AND ");
1146
1147                query.append("classNameId = ?");
1148
1149                query.append(" AND ");
1150
1151                query.append("classPK = ?");
1152
1153                query.append(" ");
1154
1155                if (obc != null) {
1156                    query.append("ORDER BY ");
1157                    query.append(obc.getOrderBy());
1158                }
1159
1160                else {
1161                    query.append("ORDER BY ");
1162
1163                    query.append("createDate ASC");
1164                }
1165
1166                Query q = session.createQuery(query.toString());
1167
1168                QueryPos qPos = QueryPos.getInstance(q);
1169
1170                qPos.add(companyId);
1171
1172                qPos.add(classNameId);
1173
1174                qPos.add(classPK);
1175
1176                List<EmailAddress> list = (List<EmailAddress>)QueryUtil.list(q,
1177                        getDialect(), start, end);
1178
1179                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1180                    finderClassName, finderMethodName, finderParams,
1181                    finderArgs, list);
1182
1183                return list;
1184            }
1185            catch (Exception e) {
1186                throw processException(e);
1187            }
1188            finally {
1189                closeSession(session);
1190            }
1191        }
1192        else {
1193            return (List<EmailAddress>)result;
1194        }
1195    }
1196
1197    public EmailAddress findByC_C_C_First(long companyId, long classNameId,
1198        long classPK, OrderByComparator obc)
1199        throws NoSuchEmailAddressException, SystemException {
1200        List<EmailAddress> list = findByC_C_C(companyId, classNameId, classPK,
1201                0, 1, obc);
1202
1203        if (list.size() == 0) {
1204            StringBuilder msg = new StringBuilder();
1205
1206            msg.append("No EmailAddress exists with the key {");
1207
1208            msg.append("companyId=" + companyId);
1209
1210            msg.append(", ");
1211            msg.append("classNameId=" + classNameId);
1212
1213            msg.append(", ");
1214            msg.append("classPK=" + classPK);
1215
1216            msg.append(StringPool.CLOSE_CURLY_BRACE);
1217
1218            throw new NoSuchEmailAddressException(msg.toString());
1219        }
1220        else {
1221            return list.get(0);
1222        }
1223    }
1224
1225    public EmailAddress findByC_C_C_Last(long companyId, long classNameId,
1226        long classPK, OrderByComparator obc)
1227        throws NoSuchEmailAddressException, SystemException {
1228        int count = countByC_C_C(companyId, classNameId, classPK);
1229
1230        List<EmailAddress> list = findByC_C_C(companyId, classNameId, classPK,
1231                count - 1, count, obc);
1232
1233        if (list.size() == 0) {
1234            StringBuilder msg = new StringBuilder();
1235
1236            msg.append("No EmailAddress exists with the key {");
1237
1238            msg.append("companyId=" + companyId);
1239
1240            msg.append(", ");
1241            msg.append("classNameId=" + classNameId);
1242
1243            msg.append(", ");
1244            msg.append("classPK=" + classPK);
1245
1246            msg.append(StringPool.CLOSE_CURLY_BRACE);
1247
1248            throw new NoSuchEmailAddressException(msg.toString());
1249        }
1250        else {
1251            return list.get(0);
1252        }
1253    }
1254
1255    public EmailAddress[] findByC_C_C_PrevAndNext(long emailAddressId,
1256        long companyId, long classNameId, long classPK, OrderByComparator obc)
1257        throws NoSuchEmailAddressException, SystemException {
1258        EmailAddress emailAddress = findByPrimaryKey(emailAddressId);
1259
1260        int count = countByC_C_C(companyId, classNameId, classPK);
1261
1262        Session session = null;
1263
1264        try {
1265            session = openSession();
1266
1267            StringBuilder query = new StringBuilder();
1268
1269            query.append("FROM com.liferay.portal.model.EmailAddress WHERE ");
1270
1271            query.append("companyId = ?");
1272
1273            query.append(" AND ");
1274
1275            query.append("classNameId = ?");
1276
1277            query.append(" AND ");
1278
1279            query.append("classPK = ?");
1280
1281            query.append(" ");
1282
1283            if (obc != null) {
1284                query.append("ORDER BY ");
1285                query.append(obc.getOrderBy());
1286            }
1287
1288            else {
1289                query.append("ORDER BY ");
1290
1291                query.append("createDate ASC");
1292            }
1293
1294            Query q = session.createQuery(query.toString());
1295
1296            QueryPos qPos = QueryPos.getInstance(q);
1297
1298            qPos.add(companyId);
1299
1300            qPos.add(classNameId);
1301
1302            qPos.add(classPK);
1303
1304            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1305                    emailAddress);
1306
1307            EmailAddress[] array = new EmailAddressImpl[3];
1308
1309            array[0] = (EmailAddress)objArray[0];
1310            array[1] = (EmailAddress)objArray[1];
1311            array[2] = (EmailAddress)objArray[2];
1312
1313            return array;
1314        }
1315        catch (Exception e) {
1316            throw processException(e);
1317        }
1318        finally {
1319            closeSession(session);
1320        }
1321    }
1322
1323    public List<EmailAddress> findByC_C_C_P(long companyId, long classNameId,
1324        long classPK, boolean primary) throws SystemException {
1325        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
1326        String finderClassName = EmailAddress.class.getName();
1327        String finderMethodName = "findByC_C_C_P";
1328        String[] finderParams = new String[] {
1329                Long.class.getName(), Long.class.getName(), Long.class.getName(),
1330                Boolean.class.getName()
1331            };
1332        Object[] finderArgs = new Object[] {
1333                new Long(companyId), new Long(classNameId), new Long(classPK),
1334                Boolean.valueOf(primary)
1335            };
1336
1337        Object result = null;
1338
1339        if (finderClassNameCacheEnabled) {
1340            result = FinderCacheUtil.getResult(finderClassName,
1341                    finderMethodName, finderParams, finderArgs, this);
1342        }
1343
1344        if (result == null) {
1345            Session session = null;
1346
1347            try {
1348                session = openSession();
1349
1350                StringBuilder query = new StringBuilder();
1351
1352                query.append(
1353                    "FROM com.liferay.portal.model.EmailAddress WHERE ");
1354
1355                query.append("companyId = ?");
1356
1357                query.append(" AND ");
1358
1359                query.append("classNameId = ?");
1360
1361                query.append(" AND ");
1362
1363                query.append("classPK = ?");
1364
1365                query.append(" AND ");
1366
1367                query.append("primary_ = ?");
1368
1369                query.append(" ");
1370
1371                query.append("ORDER BY ");
1372
1373                query.append("createDate ASC");
1374
1375                Query q = session.createQuery(query.toString());
1376
1377                QueryPos qPos = QueryPos.getInstance(q);
1378
1379                qPos.add(companyId);
1380
1381                qPos.add(classNameId);
1382
1383                qPos.add(classPK);
1384
1385                qPos.add(primary);
1386
1387                List<EmailAddress> list = q.list();
1388
1389                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1390                    finderClassName, finderMethodName, finderParams,
1391                    finderArgs, list);
1392
1393                return list;
1394            }
1395            catch (Exception e) {
1396                throw processException(e);
1397            }
1398            finally {
1399                closeSession(session);
1400            }
1401        }
1402        else {
1403            return (List<EmailAddress>)result;
1404        }
1405    }
1406
1407    public List<EmailAddress> findByC_C_C_P(long companyId, long classNameId,
1408        long classPK, boolean primary, int start, int end)
1409        throws SystemException {
1410        return findByC_C_C_P(companyId, classNameId, classPK, primary, start,
1411            end, null);
1412    }
1413
1414    public List<EmailAddress> findByC_C_C_P(long companyId, long classNameId,
1415        long classPK, boolean primary, int start, int end, OrderByComparator obc)
1416        throws SystemException {
1417        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
1418        String finderClassName = EmailAddress.class.getName();
1419        String finderMethodName = "findByC_C_C_P";
1420        String[] finderParams = new String[] {
1421                Long.class.getName(), Long.class.getName(), Long.class.getName(),
1422                Boolean.class.getName(),
1423                
1424                "java.lang.Integer", "java.lang.Integer",
1425                "com.liferay.portal.kernel.util.OrderByComparator"
1426            };
1427        Object[] finderArgs = new Object[] {
1428                new Long(companyId), new Long(classNameId), new Long(classPK),
1429                Boolean.valueOf(primary),
1430                
1431                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1432            };
1433
1434        Object result = null;
1435
1436        if (finderClassNameCacheEnabled) {
1437            result = FinderCacheUtil.getResult(finderClassName,
1438                    finderMethodName, finderParams, finderArgs, this);
1439        }
1440
1441        if (result == null) {
1442            Session session = null;
1443
1444            try {
1445                session = openSession();
1446
1447                StringBuilder query = new StringBuilder();
1448
1449                query.append(
1450                    "FROM com.liferay.portal.model.EmailAddress WHERE ");
1451
1452                query.append("companyId = ?");
1453
1454                query.append(" AND ");
1455
1456                query.append("classNameId = ?");
1457
1458                query.append(" AND ");
1459
1460                query.append("classPK = ?");
1461
1462                query.append(" AND ");
1463
1464                query.append("primary_ = ?");
1465
1466                query.append(" ");
1467
1468                if (obc != null) {
1469                    query.append("ORDER BY ");
1470                    query.append(obc.getOrderBy());
1471                }
1472
1473                else {
1474                    query.append("ORDER BY ");
1475
1476                    query.append("createDate ASC");
1477                }
1478
1479                Query q = session.createQuery(query.toString());
1480
1481                QueryPos qPos = QueryPos.getInstance(q);
1482
1483                qPos.add(companyId);
1484
1485                qPos.add(classNameId);
1486
1487                qPos.add(classPK);
1488
1489                qPos.add(primary);
1490
1491                List<EmailAddress> list = (List<EmailAddress>)QueryUtil.list(q,
1492                        getDialect(), start, end);
1493
1494                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1495                    finderClassName, finderMethodName, finderParams,
1496                    finderArgs, list);
1497
1498                return list;
1499            }
1500            catch (Exception e) {
1501                throw processException(e);
1502            }
1503            finally {
1504                closeSession(session);
1505            }
1506        }
1507        else {
1508            return (List<EmailAddress>)result;
1509        }
1510    }
1511
1512    public EmailAddress findByC_C_C_P_First(long companyId, long classNameId,
1513        long classPK, boolean primary, OrderByComparator obc)
1514        throws NoSuchEmailAddressException, SystemException {
1515        List<EmailAddress> list = findByC_C_C_P(companyId, classNameId,
1516                classPK, primary, 0, 1, obc);
1517
1518        if (list.size() == 0) {
1519            StringBuilder msg = new StringBuilder();
1520
1521            msg.append("No EmailAddress exists with the key {");
1522
1523            msg.append("companyId=" + companyId);
1524
1525            msg.append(", ");
1526            msg.append("classNameId=" + classNameId);
1527
1528            msg.append(", ");
1529            msg.append("classPK=" + classPK);
1530
1531            msg.append(", ");
1532            msg.append("primary=" + primary);
1533
1534            msg.append(StringPool.CLOSE_CURLY_BRACE);
1535
1536            throw new NoSuchEmailAddressException(msg.toString());
1537        }
1538        else {
1539            return list.get(0);
1540        }
1541    }
1542
1543    public EmailAddress findByC_C_C_P_Last(long companyId, long classNameId,
1544        long classPK, boolean primary, OrderByComparator obc)
1545        throws NoSuchEmailAddressException, SystemException {
1546        int count = countByC_C_C_P(companyId, classNameId, classPK, primary);
1547
1548        List<EmailAddress> list = findByC_C_C_P(companyId, classNameId,
1549                classPK, primary, count - 1, count, obc);
1550
1551        if (list.size() == 0) {
1552            StringBuilder msg = new StringBuilder();
1553
1554            msg.append("No EmailAddress exists with the key {");
1555
1556            msg.append("companyId=" + companyId);
1557
1558            msg.append(", ");
1559            msg.append("classNameId=" + classNameId);
1560
1561            msg.append(", ");
1562            msg.append("classPK=" + classPK);
1563
1564            msg.append(", ");
1565            msg.append("primary=" + primary);
1566
1567            msg.append(StringPool.CLOSE_CURLY_BRACE);
1568
1569            throw new NoSuchEmailAddressException(msg.toString());
1570        }
1571        else {
1572            return list.get(0);
1573        }
1574    }
1575
1576    public EmailAddress[] findByC_C_C_P_PrevAndNext(long emailAddressId,
1577        long companyId, long classNameId, long classPK, boolean primary,
1578        OrderByComparator obc)
1579        throws NoSuchEmailAddressException, SystemException {
1580        EmailAddress emailAddress = findByPrimaryKey(emailAddressId);
1581
1582        int count = countByC_C_C_P(companyId, classNameId, classPK, primary);
1583
1584        Session session = null;
1585
1586        try {
1587            session = openSession();
1588
1589            StringBuilder query = new StringBuilder();
1590
1591            query.append("FROM com.liferay.portal.model.EmailAddress WHERE ");
1592
1593            query.append("companyId = ?");
1594
1595            query.append(" AND ");
1596
1597            query.append("classNameId = ?");
1598
1599            query.append(" AND ");
1600
1601            query.append("classPK = ?");
1602
1603            query.append(" AND ");
1604
1605            query.append("primary_ = ?");
1606
1607            query.append(" ");
1608
1609            if (obc != null) {
1610                query.append("ORDER BY ");
1611                query.append(obc.getOrderBy());
1612            }
1613
1614            else {
1615                query.append("ORDER BY ");
1616
1617                query.append("createDate ASC");
1618            }
1619
1620            Query q = session.createQuery(query.toString());
1621
1622            QueryPos qPos = QueryPos.getInstance(q);
1623
1624            qPos.add(companyId);
1625
1626            qPos.add(classNameId);
1627
1628            qPos.add(classPK);
1629
1630            qPos.add(primary);
1631
1632            Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc,
1633                    emailAddress);
1634
1635            EmailAddress[] array = new EmailAddressImpl[3];
1636
1637            array[0] = (EmailAddress)objArray[0];
1638            array[1] = (EmailAddress)objArray[1];
1639            array[2] = (EmailAddress)objArray[2];
1640
1641            return array;
1642        }
1643        catch (Exception e) {
1644            throw processException(e);
1645        }
1646        finally {
1647            closeSession(session);
1648        }
1649    }
1650
1651    public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery)
1652        throws SystemException {
1653        Session session = null;
1654
1655        try {
1656            session = openSession();
1657
1658            dynamicQuery.compile(session);
1659
1660            return dynamicQuery.list();
1661        }
1662        catch (Exception e) {
1663            throw processException(e);
1664        }
1665        finally {
1666            closeSession(session);
1667        }
1668    }
1669
1670    public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery,
1671        int start, int end) throws SystemException {
1672        Session session = null;
1673
1674        try {
1675            session = openSession();
1676
1677            dynamicQuery.setLimit(start, end);
1678
1679            dynamicQuery.compile(session);
1680
1681            return dynamicQuery.list();
1682        }
1683        catch (Exception e) {
1684            throw processException(e);
1685        }
1686        finally {
1687            closeSession(session);
1688        }
1689    }
1690
1691    public List<EmailAddress> findAll() throws SystemException {
1692        return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1693    }
1694
1695    public List<EmailAddress> findAll(int start, int end)
1696        throws SystemException {
1697        return findAll(start, end, null);
1698    }
1699
1700    public List<EmailAddress> findAll(int start, int end, OrderByComparator obc)
1701        throws SystemException {
1702        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
1703        String finderClassName = EmailAddress.class.getName();
1704        String finderMethodName = "findAll";
1705        String[] finderParams = new String[] {
1706                "java.lang.Integer", "java.lang.Integer",
1707                "com.liferay.portal.kernel.util.OrderByComparator"
1708            };
1709        Object[] finderArgs = new Object[] {
1710                String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1711            };
1712
1713        Object result = null;
1714
1715        if (finderClassNameCacheEnabled) {
1716            result = FinderCacheUtil.getResult(finderClassName,
1717                    finderMethodName, finderParams, finderArgs, this);
1718        }
1719
1720        if (result == null) {
1721            Session session = null;
1722
1723            try {
1724                session = openSession();
1725
1726                StringBuilder query = new StringBuilder();
1727
1728                query.append("FROM com.liferay.portal.model.EmailAddress ");
1729
1730                if (obc != null) {
1731                    query.append("ORDER BY ");
1732                    query.append(obc.getOrderBy());
1733                }
1734
1735                else {
1736                    query.append("ORDER BY ");
1737
1738                    query.append("createDate ASC");
1739                }
1740
1741                Query q = session.createQuery(query.toString());
1742
1743                List<EmailAddress> list = (List<EmailAddress>)QueryUtil.list(q,
1744                        getDialect(), start, end);
1745
1746                if (obc == null) {
1747                    Collections.sort(list);
1748                }
1749
1750                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1751                    finderClassName, finderMethodName, finderParams,
1752                    finderArgs, list);
1753
1754                return list;
1755            }
1756            catch (Exception e) {
1757                throw processException(e);
1758            }
1759            finally {
1760                closeSession(session);
1761            }
1762        }
1763        else {
1764            return (List<EmailAddress>)result;
1765        }
1766    }
1767
1768    public void removeByCompanyId(long companyId) throws SystemException {
1769        for (EmailAddress emailAddress : findByCompanyId(companyId)) {
1770            remove(emailAddress);
1771        }
1772    }
1773
1774    public void removeByUserId(long userId) throws SystemException {
1775        for (EmailAddress emailAddress : findByUserId(userId)) {
1776            remove(emailAddress);
1777        }
1778    }
1779
1780    public void removeByC_C(long companyId, long classNameId)
1781        throws SystemException {
1782        for (EmailAddress emailAddress : findByC_C(companyId, classNameId)) {
1783            remove(emailAddress);
1784        }
1785    }
1786
1787    public void removeByC_C_C(long companyId, long classNameId, long classPK)
1788        throws SystemException {
1789        for (EmailAddress emailAddress : findByC_C_C(companyId, classNameId,
1790                classPK)) {
1791            remove(emailAddress);
1792        }
1793    }
1794
1795    public void removeByC_C_C_P(long companyId, long classNameId, long classPK,
1796        boolean primary) throws SystemException {
1797        for (EmailAddress emailAddress : findByC_C_C_P(companyId, classNameId,
1798                classPK, primary)) {
1799            remove(emailAddress);
1800        }
1801    }
1802
1803    public void removeAll() throws SystemException {
1804        for (EmailAddress emailAddress : findAll()) {
1805            remove(emailAddress);
1806        }
1807    }
1808
1809    public int countByCompanyId(long companyId) throws SystemException {
1810        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
1811        String finderClassName = EmailAddress.class.getName();
1812        String finderMethodName = "countByCompanyId";
1813        String[] finderParams = new String[] { Long.class.getName() };
1814        Object[] finderArgs = new Object[] { new Long(companyId) };
1815
1816        Object result = null;
1817
1818        if (finderClassNameCacheEnabled) {
1819            result = FinderCacheUtil.getResult(finderClassName,
1820                    finderMethodName, finderParams, finderArgs, this);
1821        }
1822
1823        if (result == null) {
1824            Session session = null;
1825
1826            try {
1827                session = openSession();
1828
1829                StringBuilder query = new StringBuilder();
1830
1831                query.append("SELECT COUNT(*) ");
1832                query.append(
1833                    "FROM com.liferay.portal.model.EmailAddress WHERE ");
1834
1835                query.append("companyId = ?");
1836
1837                query.append(" ");
1838
1839                Query q = session.createQuery(query.toString());
1840
1841                QueryPos qPos = QueryPos.getInstance(q);
1842
1843                qPos.add(companyId);
1844
1845                Long count = null;
1846
1847                Iterator<Long> itr = q.list().iterator();
1848
1849                if (itr.hasNext()) {
1850                    count = itr.next();
1851                }
1852
1853                if (count == null) {
1854                    count = new Long(0);
1855                }
1856
1857                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1858                    finderClassName, finderMethodName, finderParams,
1859                    finderArgs, count);
1860
1861                return count.intValue();
1862            }
1863            catch (Exception e) {
1864                throw processException(e);
1865            }
1866            finally {
1867                closeSession(session);
1868            }
1869        }
1870        else {
1871            return ((Long)result).intValue();
1872        }
1873    }
1874
1875    public int countByUserId(long userId) throws SystemException {
1876        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
1877        String finderClassName = EmailAddress.class.getName();
1878        String finderMethodName = "countByUserId";
1879        String[] finderParams = new String[] { Long.class.getName() };
1880        Object[] finderArgs = new Object[] { new Long(userId) };
1881
1882        Object result = null;
1883
1884        if (finderClassNameCacheEnabled) {
1885            result = FinderCacheUtil.getResult(finderClassName,
1886                    finderMethodName, finderParams, finderArgs, this);
1887        }
1888
1889        if (result == null) {
1890            Session session = null;
1891
1892            try {
1893                session = openSession();
1894
1895                StringBuilder query = new StringBuilder();
1896
1897                query.append("SELECT COUNT(*) ");
1898                query.append(
1899                    "FROM com.liferay.portal.model.EmailAddress WHERE ");
1900
1901                query.append("userId = ?");
1902
1903                query.append(" ");
1904
1905                Query q = session.createQuery(query.toString());
1906
1907                QueryPos qPos = QueryPos.getInstance(q);
1908
1909                qPos.add(userId);
1910
1911                Long count = null;
1912
1913                Iterator<Long> itr = q.list().iterator();
1914
1915                if (itr.hasNext()) {
1916                    count = itr.next();
1917                }
1918
1919                if (count == null) {
1920                    count = new Long(0);
1921                }
1922
1923                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1924                    finderClassName, finderMethodName, finderParams,
1925                    finderArgs, count);
1926
1927                return count.intValue();
1928            }
1929            catch (Exception e) {
1930                throw processException(e);
1931            }
1932            finally {
1933                closeSession(session);
1934            }
1935        }
1936        else {
1937            return ((Long)result).intValue();
1938        }
1939    }
1940
1941    public int countByC_C(long companyId, long classNameId)
1942        throws SystemException {
1943        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
1944        String finderClassName = EmailAddress.class.getName();
1945        String finderMethodName = "countByC_C";
1946        String[] finderParams = new String[] {
1947                Long.class.getName(), Long.class.getName()
1948            };
1949        Object[] finderArgs = new Object[] {
1950                new Long(companyId), new Long(classNameId)
1951            };
1952
1953        Object result = null;
1954
1955        if (finderClassNameCacheEnabled) {
1956            result = FinderCacheUtil.getResult(finderClassName,
1957                    finderMethodName, finderParams, finderArgs, this);
1958        }
1959
1960        if (result == null) {
1961            Session session = null;
1962
1963            try {
1964                session = openSession();
1965
1966                StringBuilder query = new StringBuilder();
1967
1968                query.append("SELECT COUNT(*) ");
1969                query.append(
1970                    "FROM com.liferay.portal.model.EmailAddress WHERE ");
1971
1972                query.append("companyId = ?");
1973
1974                query.append(" AND ");
1975
1976                query.append("classNameId = ?");
1977
1978                query.append(" ");
1979
1980                Query q = session.createQuery(query.toString());
1981
1982                QueryPos qPos = QueryPos.getInstance(q);
1983
1984                qPos.add(companyId);
1985
1986                qPos.add(classNameId);
1987
1988                Long count = null;
1989
1990                Iterator<Long> itr = q.list().iterator();
1991
1992                if (itr.hasNext()) {
1993                    count = itr.next();
1994                }
1995
1996                if (count == null) {
1997                    count = new Long(0);
1998                }
1999
2000                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
2001                    finderClassName, finderMethodName, finderParams,
2002                    finderArgs, count);
2003
2004                return count.intValue();
2005            }
2006            catch (Exception e) {
2007                throw processException(e);
2008            }
2009            finally {
2010                closeSession(session);
2011            }
2012        }
2013        else {
2014            return ((Long)result).intValue();
2015        }
2016    }
2017
2018    public int countByC_C_C(long companyId, long classNameId, long classPK)
2019        throws SystemException {
2020        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
2021        String finderClassName = EmailAddress.class.getName();
2022        String finderMethodName = "countByC_C_C";
2023        String[] finderParams = new String[] {
2024                Long.class.getName(), Long.class.getName(), Long.class.getName()
2025            };
2026        Object[] finderArgs = new Object[] {
2027                new Long(companyId), new Long(classNameId), new Long(classPK)
2028            };
2029
2030        Object result = null;
2031
2032        if (finderClassNameCacheEnabled) {
2033            result = FinderCacheUtil.getResult(finderClassName,
2034                    finderMethodName, finderParams, finderArgs, this);
2035        }
2036
2037        if (result == null) {
2038            Session session = null;
2039
2040            try {
2041                session = openSession();
2042
2043                StringBuilder query = new StringBuilder();
2044
2045                query.append("SELECT COUNT(*) ");
2046                query.append(
2047                    "FROM com.liferay.portal.model.EmailAddress WHERE ");
2048
2049                query.append("companyId = ?");
2050
2051                query.append(" AND ");
2052
2053                query.append("classNameId = ?");
2054
2055                query.append(" AND ");
2056
2057                query.append("classPK = ?");
2058
2059                query.append(" ");
2060
2061                Query q = session.createQuery(query.toString());
2062
2063                QueryPos qPos = QueryPos.getInstance(q);
2064
2065                qPos.add(companyId);
2066
2067                qPos.add(classNameId);
2068
2069                qPos.add(classPK);
2070
2071                Long count = null;
2072
2073                Iterator<Long> itr = q.list().iterator();
2074
2075                if (itr.hasNext()) {
2076                    count = itr.next();
2077                }
2078
2079                if (count == null) {
2080                    count = new Long(0);
2081                }
2082
2083                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
2084                    finderClassName, finderMethodName, finderParams,
2085                    finderArgs, count);
2086
2087                return count.intValue();
2088            }
2089            catch (Exception e) {
2090                throw processException(e);
2091            }
2092            finally {
2093                closeSession(session);
2094            }
2095        }
2096        else {
2097            return ((Long)result).intValue();
2098        }
2099    }
2100
2101    public int countByC_C_C_P(long companyId, long classNameId, long classPK,
2102        boolean primary) throws SystemException {
2103        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
2104        String finderClassName = EmailAddress.class.getName();
2105        String finderMethodName = "countByC_C_C_P";
2106        String[] finderParams = new String[] {
2107                Long.class.getName(), Long.class.getName(), Long.class.getName(),
2108                Boolean.class.getName()
2109            };
2110        Object[] finderArgs = new Object[] {
2111                new Long(companyId), new Long(classNameId), new Long(classPK),
2112                Boolean.valueOf(primary)
2113            };
2114
2115        Object result = null;
2116
2117        if (finderClassNameCacheEnabled) {
2118            result = FinderCacheUtil.getResult(finderClassName,
2119                    finderMethodName, finderParams, finderArgs, this);
2120        }
2121
2122        if (result == null) {
2123            Session session = null;
2124
2125            try {
2126                session = openSession();
2127
2128                StringBuilder query = new StringBuilder();
2129
2130                query.append("SELECT COUNT(*) ");
2131                query.append(
2132                    "FROM com.liferay.portal.model.EmailAddress WHERE ");
2133
2134                query.append("companyId = ?");
2135
2136                query.append(" AND ");
2137
2138                query.append("classNameId = ?");
2139
2140                query.append(" AND ");
2141
2142                query.append("classPK = ?");
2143
2144                query.append(" AND ");
2145
2146                query.append("primary_ = ?");
2147
2148                query.append(" ");
2149
2150                Query q = session.createQuery(query.toString());
2151
2152                QueryPos qPos = QueryPos.getInstance(q);
2153
2154                qPos.add(companyId);
2155
2156                qPos.add(classNameId);
2157
2158                qPos.add(classPK);
2159
2160                qPos.add(primary);
2161
2162                Long count = null;
2163
2164                Iterator<Long> itr = q.list().iterator();
2165
2166                if (itr.hasNext()) {
2167                    count = itr.next();
2168                }
2169
2170                if (count == null) {
2171                    count = new Long(0);
2172                }
2173
2174                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
2175                    finderClassName, finderMethodName, finderParams,
2176                    finderArgs, count);
2177
2178                return count.intValue();
2179            }
2180            catch (Exception e) {
2181                throw processException(e);
2182            }
2183            finally {
2184                closeSession(session);
2185            }
2186        }
2187        else {
2188            return ((Long)result).intValue();
2189        }
2190    }
2191
2192    public int countAll() throws SystemException {
2193        boolean finderClassNameCacheEnabled = EmailAddressModelImpl.CACHE_ENABLED;
2194        String finderClassName = EmailAddress.class.getName();
2195        String finderMethodName = "countAll";
2196        String[] finderParams = new String[] {  };
2197        Object[] finderArgs = new Object[] {  };
2198
2199        Object result = null;
2200
2201        if (finderClassNameCacheEnabled) {
2202            result = FinderCacheUtil.getResult(finderClassName,
2203                    finderMethodName, finderParams, finderArgs, this);
2204        }
2205
2206        if (result == null) {
2207            Session session = null;
2208
2209            try {
2210                session = openSession();
2211
2212                Query q = session.createQuery(
2213                        "SELECT COUNT(*) FROM com.liferay.portal.model.EmailAddress");
2214
2215                Long count = null;
2216
2217                Iterator<Long> itr = q.list().iterator();
2218
2219                if (itr.hasNext()) {
2220                    count = itr.next();
2221                }
2222
2223                if (count == null) {
2224                    count = new Long(0);
2225                }
2226
2227                FinderCacheUtil.putResult(finderClassNameCacheEnabled,
2228                    finderClassName, finderMethodName, finderParams,
2229                    finderArgs, count);
2230
2231                return count.intValue();
2232            }
2233            catch (Exception e) {
2234                throw processException(e);
2235            }
2236            finally {
2237                closeSession(session);
2238            }
2239        }
2240        else {
2241            return ((Long)result).intValue();
2242        }
2243    }
2244
2245    public void registerListener(ModelListener listener) {
2246        List<ModelListener> listeners = ListUtil.fromArray(_listeners);
2247
2248        listeners.add(listener);
2249
2250        _listeners = listeners.toArray(new ModelListener[listeners.size()]);
2251    }
2252
2253    public void unregisterListener(ModelListener listener) {
2254        List<ModelListener> listeners = ListUtil.fromArray(_listeners);
2255
2256        listeners.remove(listener);
2257
2258        _listeners = listeners.toArray(new ModelListener[listeners.size()]);
2259    }
2260
2261    public void afterPropertiesSet() {
2262        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
2263                    com.liferay.portal.util.PropsUtil.get(
2264                        "value.object.listener.com.liferay.portal.model.EmailAddress")));
2265
2266        if (listenerClassNames.length > 0) {
2267            try {
2268                List<ModelListener> listeners = new ArrayList<ModelListener>();
2269
2270                for (String listenerClassName : listenerClassNames) {
2271                    listeners.add((ModelListener)Class.forName(
2272                            listenerClassName).newInstance());
2273                }
2274
2275                _listeners = listeners.toArray(new ModelListener[listeners.size()]);
2276            }
2277            catch (Exception e) {
2278                _log.error(e);
2279            }
2280        }
2281    }
2282
2283    private static Log _log = LogFactory.getLog(EmailAddressPersistenceImpl.class);
2284    private ModelListener[] _listeners = new ModelListener[0];
2285}