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