1
22
23 package com.liferay.portal.service.persistence;
24
25 import com.liferay.portal.NoSuchAddressException;
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.Address;
40 import com.liferay.portal.model.ModelListener;
41 import com.liferay.portal.model.impl.AddressImpl;
42 import com.liferay.portal.model.impl.AddressModelImpl;
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
59 public class AddressPersistenceImpl extends BasePersistenceImpl
60 implements AddressPersistence, InitializingBean {
61 public Address create(long addressId) {
62 Address address = new AddressImpl();
63
64 address.setNew(true);
65 address.setPrimaryKey(addressId);
66
67 return address;
68 }
69
70 public Address remove(long addressId)
71 throws NoSuchAddressException, SystemException {
72 Session session = null;
73
74 try {
75 session = openSession();
76
77 Address address = (Address)session.get(AddressImpl.class,
78 new Long(addressId));
79
80 if (address == null) {
81 if (_log.isWarnEnabled()) {
82 _log.warn("No Address exists with the primary key " +
83 addressId);
84 }
85
86 throw new NoSuchAddressException(
87 "No Address exists with the primary key " + addressId);
88 }
89
90 return remove(address);
91 }
92 catch (NoSuchAddressException nsee) {
93 throw nsee;
94 }
95 catch (Exception e) {
96 throw processException(e);
97 }
98 finally {
99 closeSession(session);
100 }
101 }
102
103 public Address remove(Address address) throws SystemException {
104 if (_listeners.length > 0) {
105 for (ModelListener listener : _listeners) {
106 listener.onBeforeRemove(address);
107 }
108 }
109
110 address = removeImpl(address);
111
112 if (_listeners.length > 0) {
113 for (ModelListener listener : _listeners) {
114 listener.onAfterRemove(address);
115 }
116 }
117
118 return address;
119 }
120
121 protected Address removeImpl(Address address) throws SystemException {
122 Session session = null;
123
124 try {
125 session = openSession();
126
127 session.delete(address);
128
129 session.flush();
130
131 return address;
132 }
133 catch (Exception e) {
134 throw processException(e);
135 }
136 finally {
137 closeSession(session);
138
139 FinderCacheUtil.clearCache(Address.class.getName());
140 }
141 }
142
143
146 public Address update(Address address) throws SystemException {
147 if (_log.isWarnEnabled()) {
148 _log.warn(
149 "Using the deprecated update(Address address) method. Use update(Address address, boolean merge) instead.");
150 }
151
152 return update(address, false);
153 }
154
155
168 public Address update(Address address, boolean merge)
169 throws SystemException {
170 boolean isNew = address.isNew();
171
172 if (_listeners.length > 0) {
173 for (ModelListener listener : _listeners) {
174 if (isNew) {
175 listener.onBeforeCreate(address);
176 }
177 else {
178 listener.onBeforeUpdate(address);
179 }
180 }
181 }
182
183 address = updateImpl(address, merge);
184
185 if (_listeners.length > 0) {
186 for (ModelListener listener : _listeners) {
187 if (isNew) {
188 listener.onAfterCreate(address);
189 }
190 else {
191 listener.onAfterUpdate(address);
192 }
193 }
194 }
195
196 return address;
197 }
198
199 public Address updateImpl(com.liferay.portal.model.Address address,
200 boolean merge) throws SystemException {
201 Session session = null;
202
203 try {
204 session = openSession();
205
206 if (merge) {
207 session.merge(address);
208 }
209 else {
210 if (address.isNew()) {
211 session.save(address);
212 }
213 }
214
215 session.flush();
216
217 address.setNew(false);
218
219 return address;
220 }
221 catch (Exception e) {
222 throw processException(e);
223 }
224 finally {
225 closeSession(session);
226
227 FinderCacheUtil.clearCache(Address.class.getName());
228 }
229 }
230
231 public Address findByPrimaryKey(long addressId)
232 throws NoSuchAddressException, SystemException {
233 Address address = fetchByPrimaryKey(addressId);
234
235 if (address == null) {
236 if (_log.isWarnEnabled()) {
237 _log.warn("No Address exists with the primary key " +
238 addressId);
239 }
240
241 throw new NoSuchAddressException(
242 "No Address exists with the primary key " + addressId);
243 }
244
245 return address;
246 }
247
248 public Address fetchByPrimaryKey(long addressId) throws SystemException {
249 Session session = null;
250
251 try {
252 session = openSession();
253
254 return (Address)session.get(AddressImpl.class, new Long(addressId));
255 }
256 catch (Exception e) {
257 throw processException(e);
258 }
259 finally {
260 closeSession(session);
261 }
262 }
263
264 public List<Address> findByCompanyId(long companyId)
265 throws SystemException {
266 boolean finderClassNameCacheEnabled = AddressModelImpl.CACHE_ENABLED;
267 String finderClassName = Address.class.getName();
268 String finderMethodName = "findByCompanyId";
269 String[] finderParams = new String[] { Long.class.getName() };
270 Object[] finderArgs = new Object[] { new Long(companyId) };
271
272 Object result = null;
273
274 if (finderClassNameCacheEnabled) {
275 result = FinderCacheUtil.getResult(finderClassName,
276 finderMethodName, finderParams, finderArgs, this);
277 }
278
279 if (result == null) {
280 Session session = null;
281
282 try {
283 session = openSession();
284
285 StringBuilder query = new StringBuilder();
286
287 query.append("FROM com.liferay.portal.model.Address WHERE ");
288
289 query.append("companyId = ?");
290
291 query.append(" ");
292
293 query.append("ORDER BY ");
294
295 query.append("createDate ASC");
296
297 Query q = session.createQuery(query.toString());
298
299 QueryPos qPos = QueryPos.getInstance(q);
300
301 qPos.add(companyId);
302
303 List<Address> list = q.list();
304
305 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
306 finderClassName, finderMethodName, finderParams,
307 finderArgs, list);
308
309 return list;
310 }
311 catch (Exception e) {
312 throw processException(e);
313 }
314 finally {
315 closeSession(session);
316 }
317 }
318 else {
319 return (List<Address>)result;
320 }
321 }
322
323 public List<Address> findByCompanyId(long companyId, int start, int end)
324 throws SystemException {
325 return findByCompanyId(companyId, start, end, null);
326 }
327
328 public List<Address> findByCompanyId(long companyId, int start, int end,
329 OrderByComparator obc) throws SystemException {
330 boolean finderClassNameCacheEnabled = AddressModelImpl.CACHE_ENABLED;
331 String finderClassName = Address.class.getName();
332 String finderMethodName = "findByCompanyId";
333 String[] finderParams = new String[] {
334 Long.class.getName(),
335
336 "java.lang.Integer", "java.lang.Integer",
337 "com.liferay.portal.kernel.util.OrderByComparator"
338 };
339 Object[] finderArgs = new Object[] {
340 new Long(companyId),
341
342 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
343 };
344
345 Object result = null;
346
347 if (finderClassNameCacheEnabled) {
348 result = FinderCacheUtil.getResult(finderClassName,
349 finderMethodName, finderParams, finderArgs, this);
350 }
351
352 if (result == null) {
353 Session session = null;
354
355 try {
356 session = openSession();
357
358 StringBuilder query = new StringBuilder();
359
360 query.append("FROM com.liferay.portal.model.Address WHERE ");
361
362 query.append("companyId = ?");
363
364 query.append(" ");
365
366 if (obc != null) {
367 query.append("ORDER BY ");
368 query.append(obc.getOrderBy());
369 }
370
371 else {
372 query.append("ORDER BY ");
373
374 query.append("createDate ASC");
375 }
376
377 Query q = session.createQuery(query.toString());
378
379 QueryPos qPos = QueryPos.getInstance(q);
380
381 qPos.add(companyId);
382
383 List<Address> list = (List<Address>)QueryUtil.list(q,
384 getDialect(), start, end);
385
386 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
387 finderClassName, finderMethodName, finderParams,
388 finderArgs, list);
389
390 return list;
391 }
392 catch (Exception e) {
393 throw processException(e);
394 }
395 finally {
396 closeSession(session);
397 }
398 }
399 else {
400 return (List<Address>)result;
401 }
402 }
403
404 public Address findByCompanyId_First(long companyId, OrderByComparator obc)
405 throws NoSuchAddressException, SystemException {
406 List<Address> list = findByCompanyId(companyId, 0, 1, obc);
407
408 if (list.size() == 0) {
409 StringBuilder msg = new StringBuilder();
410
411 msg.append("No Address exists with the key {");
412
413 msg.append("companyId=" + companyId);
414
415 msg.append(StringPool.CLOSE_CURLY_BRACE);
416
417 throw new NoSuchAddressException(msg.toString());
418 }
419 else {
420 return list.get(0);
421 }
422 }
423
424 public Address findByCompanyId_Last(long companyId, OrderByComparator obc)
425 throws NoSuchAddressException, SystemException {
426 int count = countByCompanyId(companyId);
427
428 List<Address> list = findByCompanyId(companyId, count - 1, count, obc);
429
430 if (list.size() == 0) {
431 StringBuilder msg = new StringBuilder();
432
433 msg.append("No Address exists with the key {");
434
435 msg.append("companyId=" + companyId);
436
437 msg.append(StringPool.CLOSE_CURLY_BRACE);
438
439 throw new NoSuchAddressException(msg.toString());
440 }
441 else {
442 return list.get(0);
443 }
444 }
445
446 public Address[] findByCompanyId_PrevAndNext(long addressId,
447 long companyId, OrderByComparator obc)
448 throws NoSuchAddressException, SystemException {
449 Address address = findByPrimaryKey(addressId);
450
451 int count = countByCompanyId(companyId);
452
453 Session session = null;
454
455 try {
456 session = openSession();
457
458 StringBuilder query = new StringBuilder();
459
460 query.append("FROM com.liferay.portal.model.Address WHERE ");
461
462 query.append("companyId = ?");
463
464 query.append(" ");
465
466 if (obc != null) {
467 query.append("ORDER BY ");
468 query.append(obc.getOrderBy());
469 }
470
471 else {
472 query.append("ORDER BY ");
473
474 query.append("createDate ASC");
475 }
476
477 Query q = session.createQuery(query.toString());
478
479 QueryPos qPos = QueryPos.getInstance(q);
480
481 qPos.add(companyId);
482
483 Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc, address);
484
485 Address[] array = new AddressImpl[3];
486
487 array[0] = (Address)objArray[0];
488 array[1] = (Address)objArray[1];
489 array[2] = (Address)objArray[2];
490
491 return array;
492 }
493 catch (Exception e) {
494 throw processException(e);
495 }
496 finally {
497 closeSession(session);
498 }
499 }
500
501 public List<Address> findByUserId(long userId) throws SystemException {
502 boolean finderClassNameCacheEnabled = AddressModelImpl.CACHE_ENABLED;
503 String finderClassName = Address.class.getName();
504 String finderMethodName = "findByUserId";
505 String[] finderParams = new String[] { Long.class.getName() };
506 Object[] finderArgs = new Object[] { new Long(userId) };
507
508 Object result = null;
509
510 if (finderClassNameCacheEnabled) {
511 result = FinderCacheUtil.getResult(finderClassName,
512 finderMethodName, finderParams, finderArgs, this);
513 }
514
515 if (result == null) {
516 Session session = null;
517
518 try {
519 session = openSession();
520
521 StringBuilder query = new StringBuilder();
522
523 query.append("FROM com.liferay.portal.model.Address WHERE ");
524
525 query.append("userId = ?");
526
527 query.append(" ");
528
529 query.append("ORDER BY ");
530
531 query.append("createDate ASC");
532
533 Query q = session.createQuery(query.toString());
534
535 QueryPos qPos = QueryPos.getInstance(q);
536
537 qPos.add(userId);
538
539 List<Address> list = q.list();
540
541 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
542 finderClassName, finderMethodName, finderParams,
543 finderArgs, list);
544
545 return list;
546 }
547 catch (Exception e) {
548 throw processException(e);
549 }
550 finally {
551 closeSession(session);
552 }
553 }
554 else {
555 return (List<Address>)result;
556 }
557 }
558
559 public List<Address> findByUserId(long userId, int start, int end)
560 throws SystemException {
561 return findByUserId(userId, start, end, null);
562 }
563
564 public List<Address> findByUserId(long userId, int start, int end,
565 OrderByComparator obc) throws SystemException {
566 boolean finderClassNameCacheEnabled = AddressModelImpl.CACHE_ENABLED;
567 String finderClassName = Address.class.getName();
568 String finderMethodName = "findByUserId";
569 String[] finderParams = new String[] {
570 Long.class.getName(),
571
572 "java.lang.Integer", "java.lang.Integer",
573 "com.liferay.portal.kernel.util.OrderByComparator"
574 };
575 Object[] finderArgs = new Object[] {
576 new Long(userId),
577
578 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
579 };
580
581 Object result = null;
582
583 if (finderClassNameCacheEnabled) {
584 result = FinderCacheUtil.getResult(finderClassName,
585 finderMethodName, finderParams, finderArgs, this);
586 }
587
588 if (result == null) {
589 Session session = null;
590
591 try {
592 session = openSession();
593
594 StringBuilder query = new StringBuilder();
595
596 query.append("FROM com.liferay.portal.model.Address WHERE ");
597
598 query.append("userId = ?");
599
600 query.append(" ");
601
602 if (obc != null) {
603 query.append("ORDER BY ");
604 query.append(obc.getOrderBy());
605 }
606
607 else {
608 query.append("ORDER BY ");
609
610 query.append("createDate ASC");
611 }
612
613 Query q = session.createQuery(query.toString());
614
615 QueryPos qPos = QueryPos.getInstance(q);
616
617 qPos.add(userId);
618
619 List<Address> list = (List<Address>)QueryUtil.list(q,
620 getDialect(), start, end);
621
622 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
623 finderClassName, finderMethodName, finderParams,
624 finderArgs, list);
625
626 return list;
627 }
628 catch (Exception e) {
629 throw processException(e);
630 }
631 finally {
632 closeSession(session);
633 }
634 }
635 else {
636 return (List<Address>)result;
637 }
638 }
639
640 public Address findByUserId_First(long userId, OrderByComparator obc)
641 throws NoSuchAddressException, SystemException {
642 List<Address> list = findByUserId(userId, 0, 1, obc);
643
644 if (list.size() == 0) {
645 StringBuilder msg = new StringBuilder();
646
647 msg.append("No Address exists with the key {");
648
649 msg.append("userId=" + userId);
650
651 msg.append(StringPool.CLOSE_CURLY_BRACE);
652
653 throw new NoSuchAddressException(msg.toString());
654 }
655 else {
656 return list.get(0);
657 }
658 }
659
660 public Address findByUserId_Last(long userId, OrderByComparator obc)
661 throws NoSuchAddressException, SystemException {
662 int count = countByUserId(userId);
663
664 List<Address> list = findByUserId(userId, count - 1, count, obc);
665
666 if (list.size() == 0) {
667 StringBuilder msg = new StringBuilder();
668
669 msg.append("No Address exists with the key {");
670
671 msg.append("userId=" + userId);
672
673 msg.append(StringPool.CLOSE_CURLY_BRACE);
674
675 throw new NoSuchAddressException(msg.toString());
676 }
677 else {
678 return list.get(0);
679 }
680 }
681
682 public Address[] findByUserId_PrevAndNext(long addressId, long userId,
683 OrderByComparator obc) throws NoSuchAddressException, SystemException {
684 Address address = findByPrimaryKey(addressId);
685
686 int count = countByUserId(userId);
687
688 Session session = null;
689
690 try {
691 session = openSession();
692
693 StringBuilder query = new StringBuilder();
694
695 query.append("FROM com.liferay.portal.model.Address WHERE ");
696
697 query.append("userId = ?");
698
699 query.append(" ");
700
701 if (obc != null) {
702 query.append("ORDER BY ");
703 query.append(obc.getOrderBy());
704 }
705
706 else {
707 query.append("ORDER BY ");
708
709 query.append("createDate ASC");
710 }
711
712 Query q = session.createQuery(query.toString());
713
714 QueryPos qPos = QueryPos.getInstance(q);
715
716 qPos.add(userId);
717
718 Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc, address);
719
720 Address[] array = new AddressImpl[3];
721
722 array[0] = (Address)objArray[0];
723 array[1] = (Address)objArray[1];
724 array[2] = (Address)objArray[2];
725
726 return array;
727 }
728 catch (Exception e) {
729 throw processException(e);
730 }
731 finally {
732 closeSession(session);
733 }
734 }
735
736 public List<Address> findByC_C(long companyId, long classNameId)
737 throws SystemException {
738 boolean finderClassNameCacheEnabled = AddressModelImpl.CACHE_ENABLED;
739 String finderClassName = Address.class.getName();
740 String finderMethodName = "findByC_C";
741 String[] finderParams = new String[] {
742 Long.class.getName(), Long.class.getName()
743 };
744 Object[] finderArgs = new Object[] {
745 new Long(companyId), new Long(classNameId)
746 };
747
748 Object result = null;
749
750 if (finderClassNameCacheEnabled) {
751 result = FinderCacheUtil.getResult(finderClassName,
752 finderMethodName, finderParams, finderArgs, this);
753 }
754
755 if (result == null) {
756 Session session = null;
757
758 try {
759 session = openSession();
760
761 StringBuilder query = new StringBuilder();
762
763 query.append("FROM com.liferay.portal.model.Address WHERE ");
764
765 query.append("companyId = ?");
766
767 query.append(" AND ");
768
769 query.append("classNameId = ?");
770
771 query.append(" ");
772
773 query.append("ORDER BY ");
774
775 query.append("createDate ASC");
776
777 Query q = session.createQuery(query.toString());
778
779 QueryPos qPos = QueryPos.getInstance(q);
780
781 qPos.add(companyId);
782
783 qPos.add(classNameId);
784
785 List<Address> list = q.list();
786
787 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
788 finderClassName, finderMethodName, finderParams,
789 finderArgs, list);
790
791 return list;
792 }
793 catch (Exception e) {
794 throw processException(e);
795 }
796 finally {
797 closeSession(session);
798 }
799 }
800 else {
801 return (List<Address>)result;
802 }
803 }
804
805 public List<Address> findByC_C(long companyId, long classNameId, int start,
806 int end) throws SystemException {
807 return findByC_C(companyId, classNameId, start, end, null);
808 }
809
810 public List<Address> findByC_C(long companyId, long classNameId, int start,
811 int end, OrderByComparator obc) throws SystemException {
812 boolean finderClassNameCacheEnabled = AddressModelImpl.CACHE_ENABLED;
813 String finderClassName = Address.class.getName();
814 String finderMethodName = "findByC_C";
815 String[] finderParams = new String[] {
816 Long.class.getName(), Long.class.getName(),
817
818 "java.lang.Integer", "java.lang.Integer",
819 "com.liferay.portal.kernel.util.OrderByComparator"
820 };
821 Object[] finderArgs = new Object[] {
822 new Long(companyId), new Long(classNameId),
823
824 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
825 };
826
827 Object result = null;
828
829 if (finderClassNameCacheEnabled) {
830 result = FinderCacheUtil.getResult(finderClassName,
831 finderMethodName, finderParams, finderArgs, this);
832 }
833
834 if (result == null) {
835 Session session = null;
836
837 try {
838 session = openSession();
839
840 StringBuilder query = new StringBuilder();
841
842 query.append("FROM com.liferay.portal.model.Address WHERE ");
843
844 query.append("companyId = ?");
845
846 query.append(" AND ");
847
848 query.append("classNameId = ?");
849
850 query.append(" ");
851
852 if (obc != null) {
853 query.append("ORDER BY ");
854 query.append(obc.getOrderBy());
855 }
856
857 else {
858 query.append("ORDER BY ");
859
860 query.append("createDate ASC");
861 }
862
863 Query q = session.createQuery(query.toString());
864
865 QueryPos qPos = QueryPos.getInstance(q);
866
867 qPos.add(companyId);
868
869 qPos.add(classNameId);
870
871 List<Address> list = (List<Address>)QueryUtil.list(q,
872 getDialect(), start, end);
873
874 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
875 finderClassName, finderMethodName, finderParams,
876 finderArgs, list);
877
878 return list;
879 }
880 catch (Exception e) {
881 throw processException(e);
882 }
883 finally {
884 closeSession(session);
885 }
886 }
887 else {
888 return (List<Address>)result;
889 }
890 }
891
892 public Address findByC_C_First(long companyId, long classNameId,
893 OrderByComparator obc) throws NoSuchAddressException, SystemException {
894 List<Address> list = findByC_C(companyId, classNameId, 0, 1, obc);
895
896 if (list.size() == 0) {
897 StringBuilder msg = new StringBuilder();
898
899 msg.append("No Address exists with the key {");
900
901 msg.append("companyId=" + companyId);
902
903 msg.append(", ");
904 msg.append("classNameId=" + classNameId);
905
906 msg.append(StringPool.CLOSE_CURLY_BRACE);
907
908 throw new NoSuchAddressException(msg.toString());
909 }
910 else {
911 return list.get(0);
912 }
913 }
914
915 public Address findByC_C_Last(long companyId, long classNameId,
916 OrderByComparator obc) throws NoSuchAddressException, SystemException {
917 int count = countByC_C(companyId, classNameId);
918
919 List<Address> list = findByC_C(companyId, classNameId, count - 1,
920 count, obc);
921
922 if (list.size() == 0) {
923 StringBuilder msg = new StringBuilder();
924
925 msg.append("No Address exists with the key {");
926
927 msg.append("companyId=" + companyId);
928
929 msg.append(", ");
930 msg.append("classNameId=" + classNameId);
931
932 msg.append(StringPool.CLOSE_CURLY_BRACE);
933
934 throw new NoSuchAddressException(msg.toString());
935 }
936 else {
937 return list.get(0);
938 }
939 }
940
941 public Address[] findByC_C_PrevAndNext(long addressId, long companyId,
942 long classNameId, OrderByComparator obc)
943 throws NoSuchAddressException, SystemException {
944 Address address = findByPrimaryKey(addressId);
945
946 int count = countByC_C(companyId, classNameId);
947
948 Session session = null;
949
950 try {
951 session = openSession();
952
953 StringBuilder query = new StringBuilder();
954
955 query.append("FROM com.liferay.portal.model.Address WHERE ");
956
957 query.append("companyId = ?");
958
959 query.append(" AND ");
960
961 query.append("classNameId = ?");
962
963 query.append(" ");
964
965 if (obc != null) {
966 query.append("ORDER BY ");
967 query.append(obc.getOrderBy());
968 }
969
970 else {
971 query.append("ORDER BY ");
972
973 query.append("createDate ASC");
974 }
975
976 Query q = session.createQuery(query.toString());
977
978 QueryPos qPos = QueryPos.getInstance(q);
979
980 qPos.add(companyId);
981
982 qPos.add(classNameId);
983
984 Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc, address);
985
986 Address[] array = new AddressImpl[3];
987
988 array[0] = (Address)objArray[0];
989 array[1] = (Address)objArray[1];
990 array[2] = (Address)objArray[2];
991
992 return array;
993 }
994 catch (Exception e) {
995 throw processException(e);
996 }
997 finally {
998 closeSession(session);
999 }
1000 }
1001
1002 public List<Address> findByC_C_C(long companyId, long classNameId,
1003 long classPK) throws SystemException {
1004 boolean finderClassNameCacheEnabled = AddressModelImpl.CACHE_ENABLED;
1005 String finderClassName = Address.class.getName();
1006 String finderMethodName = "findByC_C_C";
1007 String[] finderParams = new String[] {
1008 Long.class.getName(), Long.class.getName(), Long.class.getName()
1009 };
1010 Object[] finderArgs = new Object[] {
1011 new Long(companyId), new Long(classNameId), new Long(classPK)
1012 };
1013
1014 Object result = null;
1015
1016 if (finderClassNameCacheEnabled) {
1017 result = FinderCacheUtil.getResult(finderClassName,
1018 finderMethodName, finderParams, finderArgs, this);
1019 }
1020
1021 if (result == null) {
1022 Session session = null;
1023
1024 try {
1025 session = openSession();
1026
1027 StringBuilder query = new StringBuilder();
1028
1029 query.append("FROM com.liferay.portal.model.Address WHERE ");
1030
1031 query.append("companyId = ?");
1032
1033 query.append(" AND ");
1034
1035 query.append("classNameId = ?");
1036
1037 query.append(" AND ");
1038
1039 query.append("classPK = ?");
1040
1041 query.append(" ");
1042
1043 query.append("ORDER BY ");
1044
1045 query.append("createDate ASC");
1046
1047 Query q = session.createQuery(query.toString());
1048
1049 QueryPos qPos = QueryPos.getInstance(q);
1050
1051 qPos.add(companyId);
1052
1053 qPos.add(classNameId);
1054
1055 qPos.add(classPK);
1056
1057 List<Address> list = q.list();
1058
1059 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1060 finderClassName, finderMethodName, finderParams,
1061 finderArgs, list);
1062
1063 return list;
1064 }
1065 catch (Exception e) {
1066 throw processException(e);
1067 }
1068 finally {
1069 closeSession(session);
1070 }
1071 }
1072 else {
1073 return (List<Address>)result;
1074 }
1075 }
1076
1077 public List<Address> findByC_C_C(long companyId, long classNameId,
1078 long classPK, int start, int end) throws SystemException {
1079 return findByC_C_C(companyId, classNameId, classPK, start, end, null);
1080 }
1081
1082 public List<Address> findByC_C_C(long companyId, long classNameId,
1083 long classPK, int start, int end, OrderByComparator obc)
1084 throws SystemException {
1085 boolean finderClassNameCacheEnabled = AddressModelImpl.CACHE_ENABLED;
1086 String finderClassName = Address.class.getName();
1087 String finderMethodName = "findByC_C_C";
1088 String[] finderParams = new String[] {
1089 Long.class.getName(), Long.class.getName(), Long.class.getName(),
1090
1091 "java.lang.Integer", "java.lang.Integer",
1092 "com.liferay.portal.kernel.util.OrderByComparator"
1093 };
1094 Object[] finderArgs = new Object[] {
1095 new Long(companyId), new Long(classNameId), new Long(classPK),
1096
1097 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1098 };
1099
1100 Object result = null;
1101
1102 if (finderClassNameCacheEnabled) {
1103 result = FinderCacheUtil.getResult(finderClassName,
1104 finderMethodName, finderParams, finderArgs, this);
1105 }
1106
1107 if (result == null) {
1108 Session session = null;
1109
1110 try {
1111 session = openSession();
1112
1113 StringBuilder query = new StringBuilder();
1114
1115 query.append("FROM com.liferay.portal.model.Address WHERE ");
1116
1117 query.append("companyId = ?");
1118
1119 query.append(" AND ");
1120
1121 query.append("classNameId = ?");
1122
1123 query.append(" AND ");
1124
1125 query.append("classPK = ?");
1126
1127 query.append(" ");
1128
1129 if (obc != null) {
1130 query.append("ORDER BY ");
1131 query.append(obc.getOrderBy());
1132 }
1133
1134 else {
1135 query.append("ORDER BY ");
1136
1137 query.append("createDate ASC");
1138 }
1139
1140 Query q = session.createQuery(query.toString());
1141
1142 QueryPos qPos = QueryPos.getInstance(q);
1143
1144 qPos.add(companyId);
1145
1146 qPos.add(classNameId);
1147
1148 qPos.add(classPK);
1149
1150 List<Address> list = (List<Address>)QueryUtil.list(q,
1151 getDialect(), start, end);
1152
1153 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1154 finderClassName, finderMethodName, finderParams,
1155 finderArgs, list);
1156
1157 return list;
1158 }
1159 catch (Exception e) {
1160 throw processException(e);
1161 }
1162 finally {
1163 closeSession(session);
1164 }
1165 }
1166 else {
1167 return (List<Address>)result;
1168 }
1169 }
1170
1171 public Address findByC_C_C_First(long companyId, long classNameId,
1172 long classPK, OrderByComparator obc)
1173 throws NoSuchAddressException, SystemException {
1174 List<Address> list = findByC_C_C(companyId, classNameId, classPK, 0, 1,
1175 obc);
1176
1177 if (list.size() == 0) {
1178 StringBuilder msg = new StringBuilder();
1179
1180 msg.append("No Address exists with the key {");
1181
1182 msg.append("companyId=" + companyId);
1183
1184 msg.append(", ");
1185 msg.append("classNameId=" + classNameId);
1186
1187 msg.append(", ");
1188 msg.append("classPK=" + classPK);
1189
1190 msg.append(StringPool.CLOSE_CURLY_BRACE);
1191
1192 throw new NoSuchAddressException(msg.toString());
1193 }
1194 else {
1195 return list.get(0);
1196 }
1197 }
1198
1199 public Address findByC_C_C_Last(long companyId, long classNameId,
1200 long classPK, OrderByComparator obc)
1201 throws NoSuchAddressException, SystemException {
1202 int count = countByC_C_C(companyId, classNameId, classPK);
1203
1204 List<Address> list = findByC_C_C(companyId, classNameId, classPK,
1205 count - 1, count, obc);
1206
1207 if (list.size() == 0) {
1208 StringBuilder msg = new StringBuilder();
1209
1210 msg.append("No Address exists with the key {");
1211
1212 msg.append("companyId=" + companyId);
1213
1214 msg.append(", ");
1215 msg.append("classNameId=" + classNameId);
1216
1217 msg.append(", ");
1218 msg.append("classPK=" + classPK);
1219
1220 msg.append(StringPool.CLOSE_CURLY_BRACE);
1221
1222 throw new NoSuchAddressException(msg.toString());
1223 }
1224 else {
1225 return list.get(0);
1226 }
1227 }
1228
1229 public Address[] findByC_C_C_PrevAndNext(long addressId, long companyId,
1230 long classNameId, long classPK, OrderByComparator obc)
1231 throws NoSuchAddressException, SystemException {
1232 Address address = findByPrimaryKey(addressId);
1233
1234 int count = countByC_C_C(companyId, classNameId, classPK);
1235
1236 Session session = null;
1237
1238 try {
1239 session = openSession();
1240
1241 StringBuilder query = new StringBuilder();
1242
1243 query.append("FROM com.liferay.portal.model.Address WHERE ");
1244
1245 query.append("companyId = ?");
1246
1247 query.append(" AND ");
1248
1249 query.append("classNameId = ?");
1250
1251 query.append(" AND ");
1252
1253 query.append("classPK = ?");
1254
1255 query.append(" ");
1256
1257 if (obc != null) {
1258 query.append("ORDER BY ");
1259 query.append(obc.getOrderBy());
1260 }
1261
1262 else {
1263 query.append("ORDER BY ");
1264
1265 query.append("createDate ASC");
1266 }
1267
1268 Query q = session.createQuery(query.toString());
1269
1270 QueryPos qPos = QueryPos.getInstance(q);
1271
1272 qPos.add(companyId);
1273
1274 qPos.add(classNameId);
1275
1276 qPos.add(classPK);
1277
1278 Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc, address);
1279
1280 Address[] array = new AddressImpl[3];
1281
1282 array[0] = (Address)objArray[0];
1283 array[1] = (Address)objArray[1];
1284 array[2] = (Address)objArray[2];
1285
1286 return array;
1287 }
1288 catch (Exception e) {
1289 throw processException(e);
1290 }
1291 finally {
1292 closeSession(session);
1293 }
1294 }
1295
1296 public List<Address> findByC_C_C_M(long companyId, long classNameId,
1297 long classPK, boolean mailing) throws SystemException {
1298 boolean finderClassNameCacheEnabled = AddressModelImpl.CACHE_ENABLED;
1299 String finderClassName = Address.class.getName();
1300 String finderMethodName = "findByC_C_C_M";
1301 String[] finderParams = new String[] {
1302 Long.class.getName(), Long.class.getName(), Long.class.getName(),
1303 Boolean.class.getName()
1304 };
1305 Object[] finderArgs = new Object[] {
1306 new Long(companyId), new Long(classNameId), new Long(classPK),
1307 Boolean.valueOf(mailing)
1308 };
1309
1310 Object result = null;
1311
1312 if (finderClassNameCacheEnabled) {
1313 result = FinderCacheUtil.getResult(finderClassName,
1314 finderMethodName, finderParams, finderArgs, this);
1315 }
1316
1317 if (result == null) {
1318 Session session = null;
1319
1320 try {
1321 session = openSession();
1322
1323 StringBuilder query = new StringBuilder();
1324
1325 query.append("FROM com.liferay.portal.model.Address WHERE ");
1326
1327 query.append("companyId = ?");
1328
1329 query.append(" AND ");
1330
1331 query.append("classNameId = ?");
1332
1333 query.append(" AND ");
1334
1335 query.append("classPK = ?");
1336
1337 query.append(" AND ");
1338
1339 query.append("mailing = ?");
1340
1341 query.append(" ");
1342
1343 query.append("ORDER BY ");
1344
1345 query.append("createDate ASC");
1346
1347 Query q = session.createQuery(query.toString());
1348
1349 QueryPos qPos = QueryPos.getInstance(q);
1350
1351 qPos.add(companyId);
1352
1353 qPos.add(classNameId);
1354
1355 qPos.add(classPK);
1356
1357 qPos.add(mailing);
1358
1359 List<Address> list = q.list();
1360
1361 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1362 finderClassName, finderMethodName, finderParams,
1363 finderArgs, list);
1364
1365 return list;
1366 }
1367 catch (Exception e) {
1368 throw processException(e);
1369 }
1370 finally {
1371 closeSession(session);
1372 }
1373 }
1374 else {
1375 return (List<Address>)result;
1376 }
1377 }
1378
1379 public List<Address> findByC_C_C_M(long companyId, long classNameId,
1380 long classPK, boolean mailing, int start, int end)
1381 throws SystemException {
1382 return findByC_C_C_M(companyId, classNameId, classPK, mailing, start,
1383 end, null);
1384 }
1385
1386 public List<Address> findByC_C_C_M(long companyId, long classNameId,
1387 long classPK, boolean mailing, int start, int end, OrderByComparator obc)
1388 throws SystemException {
1389 boolean finderClassNameCacheEnabled = AddressModelImpl.CACHE_ENABLED;
1390 String finderClassName = Address.class.getName();
1391 String finderMethodName = "findByC_C_C_M";
1392 String[] finderParams = new String[] {
1393 Long.class.getName(), Long.class.getName(), Long.class.getName(),
1394 Boolean.class.getName(),
1395
1396 "java.lang.Integer", "java.lang.Integer",
1397 "com.liferay.portal.kernel.util.OrderByComparator"
1398 };
1399 Object[] finderArgs = new Object[] {
1400 new Long(companyId), new Long(classNameId), new Long(classPK),
1401 Boolean.valueOf(mailing),
1402
1403 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1404 };
1405
1406 Object result = null;
1407
1408 if (finderClassNameCacheEnabled) {
1409 result = FinderCacheUtil.getResult(finderClassName,
1410 finderMethodName, finderParams, finderArgs, this);
1411 }
1412
1413 if (result == null) {
1414 Session session = null;
1415
1416 try {
1417 session = openSession();
1418
1419 StringBuilder query = new StringBuilder();
1420
1421 query.append("FROM com.liferay.portal.model.Address WHERE ");
1422
1423 query.append("companyId = ?");
1424
1425 query.append(" AND ");
1426
1427 query.append("classNameId = ?");
1428
1429 query.append(" AND ");
1430
1431 query.append("classPK = ?");
1432
1433 query.append(" AND ");
1434
1435 query.append("mailing = ?");
1436
1437 query.append(" ");
1438
1439 if (obc != null) {
1440 query.append("ORDER BY ");
1441 query.append(obc.getOrderBy());
1442 }
1443
1444 else {
1445 query.append("ORDER BY ");
1446
1447 query.append("createDate ASC");
1448 }
1449
1450 Query q = session.createQuery(query.toString());
1451
1452 QueryPos qPos = QueryPos.getInstance(q);
1453
1454 qPos.add(companyId);
1455
1456 qPos.add(classNameId);
1457
1458 qPos.add(classPK);
1459
1460 qPos.add(mailing);
1461
1462 List<Address> list = (List<Address>)QueryUtil.list(q,
1463 getDialect(), start, end);
1464
1465 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1466 finderClassName, finderMethodName, finderParams,
1467 finderArgs, list);
1468
1469 return list;
1470 }
1471 catch (Exception e) {
1472 throw processException(e);
1473 }
1474 finally {
1475 closeSession(session);
1476 }
1477 }
1478 else {
1479 return (List<Address>)result;
1480 }
1481 }
1482
1483 public Address findByC_C_C_M_First(long companyId, long classNameId,
1484 long classPK, boolean mailing, OrderByComparator obc)
1485 throws NoSuchAddressException, SystemException {
1486 List<Address> list = findByC_C_C_M(companyId, classNameId, classPK,
1487 mailing, 0, 1, obc);
1488
1489 if (list.size() == 0) {
1490 StringBuilder msg = new StringBuilder();
1491
1492 msg.append("No Address exists with the key {");
1493
1494 msg.append("companyId=" + companyId);
1495
1496 msg.append(", ");
1497 msg.append("classNameId=" + classNameId);
1498
1499 msg.append(", ");
1500 msg.append("classPK=" + classPK);
1501
1502 msg.append(", ");
1503 msg.append("mailing=" + mailing);
1504
1505 msg.append(StringPool.CLOSE_CURLY_BRACE);
1506
1507 throw new NoSuchAddressException(msg.toString());
1508 }
1509 else {
1510 return list.get(0);
1511 }
1512 }
1513
1514 public Address findByC_C_C_M_Last(long companyId, long classNameId,
1515 long classPK, boolean mailing, OrderByComparator obc)
1516 throws NoSuchAddressException, SystemException {
1517 int count = countByC_C_C_M(companyId, classNameId, classPK, mailing);
1518
1519 List<Address> list = findByC_C_C_M(companyId, classNameId, classPK,
1520 mailing, count - 1, count, obc);
1521
1522 if (list.size() == 0) {
1523 StringBuilder msg = new StringBuilder();
1524
1525 msg.append("No Address exists with the key {");
1526
1527 msg.append("companyId=" + companyId);
1528
1529 msg.append(", ");
1530 msg.append("classNameId=" + classNameId);
1531
1532 msg.append(", ");
1533 msg.append("classPK=" + classPK);
1534
1535 msg.append(", ");
1536 msg.append("mailing=" + mailing);
1537
1538 msg.append(StringPool.CLOSE_CURLY_BRACE);
1539
1540 throw new NoSuchAddressException(msg.toString());
1541 }
1542 else {
1543 return list.get(0);
1544 }
1545 }
1546
1547 public Address[] findByC_C_C_M_PrevAndNext(long addressId, long companyId,
1548 long classNameId, long classPK, boolean mailing, OrderByComparator obc)
1549 throws NoSuchAddressException, SystemException {
1550 Address address = findByPrimaryKey(addressId);
1551
1552 int count = countByC_C_C_M(companyId, classNameId, classPK, mailing);
1553
1554 Session session = null;
1555
1556 try {
1557 session = openSession();
1558
1559 StringBuilder query = new StringBuilder();
1560
1561 query.append("FROM com.liferay.portal.model.Address WHERE ");
1562
1563 query.append("companyId = ?");
1564
1565 query.append(" AND ");
1566
1567 query.append("classNameId = ?");
1568
1569 query.append(" AND ");
1570
1571 query.append("classPK = ?");
1572
1573 query.append(" AND ");
1574
1575 query.append("mailing = ?");
1576
1577 query.append(" ");
1578
1579 if (obc != null) {
1580 query.append("ORDER BY ");
1581 query.append(obc.getOrderBy());
1582 }
1583
1584 else {
1585 query.append("ORDER BY ");
1586
1587 query.append("createDate ASC");
1588 }
1589
1590 Query q = session.createQuery(query.toString());
1591
1592 QueryPos qPos = QueryPos.getInstance(q);
1593
1594 qPos.add(companyId);
1595
1596 qPos.add(classNameId);
1597
1598 qPos.add(classPK);
1599
1600 qPos.add(mailing);
1601
1602 Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc, address);
1603
1604 Address[] array = new AddressImpl[3];
1605
1606 array[0] = (Address)objArray[0];
1607 array[1] = (Address)objArray[1];
1608 array[2] = (Address)objArray[2];
1609
1610 return array;
1611 }
1612 catch (Exception e) {
1613 throw processException(e);
1614 }
1615 finally {
1616 closeSession(session);
1617 }
1618 }
1619
1620 public List<Address> findByC_C_C_P(long companyId, long classNameId,
1621 long classPK, boolean primary) throws SystemException {
1622 boolean finderClassNameCacheEnabled = AddressModelImpl.CACHE_ENABLED;
1623 String finderClassName = Address.class.getName();
1624 String finderMethodName = "findByC_C_C_P";
1625 String[] finderParams = new String[] {
1626 Long.class.getName(), Long.class.getName(), Long.class.getName(),
1627 Boolean.class.getName()
1628 };
1629 Object[] finderArgs = new Object[] {
1630 new Long(companyId), new Long(classNameId), new Long(classPK),
1631 Boolean.valueOf(primary)
1632 };
1633
1634 Object result = null;
1635
1636 if (finderClassNameCacheEnabled) {
1637 result = FinderCacheUtil.getResult(finderClassName,
1638 finderMethodName, finderParams, finderArgs, this);
1639 }
1640
1641 if (result == null) {
1642 Session session = null;
1643
1644 try {
1645 session = openSession();
1646
1647 StringBuilder query = new StringBuilder();
1648
1649 query.append("FROM com.liferay.portal.model.Address WHERE ");
1650
1651 query.append("companyId = ?");
1652
1653 query.append(" AND ");
1654
1655 query.append("classNameId = ?");
1656
1657 query.append(" AND ");
1658
1659 query.append("classPK = ?");
1660
1661 query.append(" AND ");
1662
1663 query.append("primary_ = ?");
1664
1665 query.append(" ");
1666
1667 query.append("ORDER BY ");
1668
1669 query.append("createDate ASC");
1670
1671 Query q = session.createQuery(query.toString());
1672
1673 QueryPos qPos = QueryPos.getInstance(q);
1674
1675 qPos.add(companyId);
1676
1677 qPos.add(classNameId);
1678
1679 qPos.add(classPK);
1680
1681 qPos.add(primary);
1682
1683 List<Address> list = q.list();
1684
1685 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1686 finderClassName, finderMethodName, finderParams,
1687 finderArgs, list);
1688
1689 return list;
1690 }
1691 catch (Exception e) {
1692 throw processException(e);
1693 }
1694 finally {
1695 closeSession(session);
1696 }
1697 }
1698 else {
1699 return (List<Address>)result;
1700 }
1701 }
1702
1703 public List<Address> findByC_C_C_P(long companyId, long classNameId,
1704 long classPK, boolean primary, int start, int end)
1705 throws SystemException {
1706 return findByC_C_C_P(companyId, classNameId, classPK, primary, start,
1707 end, null);
1708 }
1709
1710 public List<Address> findByC_C_C_P(long companyId, long classNameId,
1711 long classPK, boolean primary, int start, int end, OrderByComparator obc)
1712 throws SystemException {
1713 boolean finderClassNameCacheEnabled = AddressModelImpl.CACHE_ENABLED;
1714 String finderClassName = Address.class.getName();
1715 String finderMethodName = "findByC_C_C_P";
1716 String[] finderParams = new String[] {
1717 Long.class.getName(), Long.class.getName(), Long.class.getName(),
1718 Boolean.class.getName(),
1719
1720 "java.lang.Integer", "java.lang.Integer",
1721 "com.liferay.portal.kernel.util.OrderByComparator"
1722 };
1723 Object[] finderArgs = new Object[] {
1724 new Long(companyId), new Long(classNameId), new Long(classPK),
1725 Boolean.valueOf(primary),
1726
1727 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
1728 };
1729
1730 Object result = null;
1731
1732 if (finderClassNameCacheEnabled) {
1733 result = FinderCacheUtil.getResult(finderClassName,
1734 finderMethodName, finderParams, finderArgs, this);
1735 }
1736
1737 if (result == null) {
1738 Session session = null;
1739
1740 try {
1741 session = openSession();
1742
1743 StringBuilder query = new StringBuilder();
1744
1745 query.append("FROM com.liferay.portal.model.Address WHERE ");
1746
1747 query.append("companyId = ?");
1748
1749 query.append(" AND ");
1750
1751 query.append("classNameId = ?");
1752
1753 query.append(" AND ");
1754
1755 query.append("classPK = ?");
1756
1757 query.append(" AND ");
1758
1759 query.append("primary_ = ?");
1760
1761 query.append(" ");
1762
1763 if (obc != null) {
1764 query.append("ORDER BY ");
1765 query.append(obc.getOrderBy());
1766 }
1767
1768 else {
1769 query.append("ORDER BY ");
1770
1771 query.append("createDate ASC");
1772 }
1773
1774 Query q = session.createQuery(query.toString());
1775
1776 QueryPos qPos = QueryPos.getInstance(q);
1777
1778 qPos.add(companyId);
1779
1780 qPos.add(classNameId);
1781
1782 qPos.add(classPK);
1783
1784 qPos.add(primary);
1785
1786 List<Address> list = (List<Address>)QueryUtil.list(q,
1787 getDialect(), start, end);
1788
1789 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
1790 finderClassName, finderMethodName, finderParams,
1791 finderArgs, list);
1792
1793 return list;
1794 }
1795 catch (Exception e) {
1796 throw processException(e);
1797 }
1798 finally {
1799 closeSession(session);
1800 }
1801 }
1802 else {
1803 return (List<Address>)result;
1804 }
1805 }
1806
1807 public Address findByC_C_C_P_First(long companyId, long classNameId,
1808 long classPK, boolean primary, OrderByComparator obc)
1809 throws NoSuchAddressException, SystemException {
1810 List<Address> list = findByC_C_C_P(companyId, classNameId, classPK,
1811 primary, 0, 1, obc);
1812
1813 if (list.size() == 0) {
1814 StringBuilder msg = new StringBuilder();
1815
1816 msg.append("No Address exists with the key {");
1817
1818 msg.append("companyId=" + companyId);
1819
1820 msg.append(", ");
1821 msg.append("classNameId=" + classNameId);
1822
1823 msg.append(", ");
1824 msg.append("classPK=" + classPK);
1825
1826 msg.append(", ");
1827 msg.append("primary=" + primary);
1828
1829 msg.append(StringPool.CLOSE_CURLY_BRACE);
1830
1831 throw new NoSuchAddressException(msg.toString());
1832 }
1833 else {
1834 return list.get(0);
1835 }
1836 }
1837
1838 public Address findByC_C_C_P_Last(long companyId, long classNameId,
1839 long classPK, boolean primary, OrderByComparator obc)
1840 throws NoSuchAddressException, SystemException {
1841 int count = countByC_C_C_P(companyId, classNameId, classPK, primary);
1842
1843 List<Address> list = findByC_C_C_P(companyId, classNameId, classPK,
1844 primary, count - 1, count, obc);
1845
1846 if (list.size() == 0) {
1847 StringBuilder msg = new StringBuilder();
1848
1849 msg.append("No Address exists with the key {");
1850
1851 msg.append("companyId=" + companyId);
1852
1853 msg.append(", ");
1854 msg.append("classNameId=" + classNameId);
1855
1856 msg.append(", ");
1857 msg.append("classPK=" + classPK);
1858
1859 msg.append(", ");
1860 msg.append("primary=" + primary);
1861
1862 msg.append(StringPool.CLOSE_CURLY_BRACE);
1863
1864 throw new NoSuchAddressException(msg.toString());
1865 }
1866 else {
1867 return list.get(0);
1868 }
1869 }
1870
1871 public Address[] findByC_C_C_P_PrevAndNext(long addressId, long companyId,
1872 long classNameId, long classPK, boolean primary, OrderByComparator obc)
1873 throws NoSuchAddressException, SystemException {
1874 Address address = findByPrimaryKey(addressId);
1875
1876 int count = countByC_C_C_P(companyId, classNameId, classPK, primary);
1877
1878 Session session = null;
1879
1880 try {
1881 session = openSession();
1882
1883 StringBuilder query = new StringBuilder();
1884
1885 query.append("FROM com.liferay.portal.model.Address WHERE ");
1886
1887 query.append("companyId = ?");
1888
1889 query.append(" AND ");
1890
1891 query.append("classNameId = ?");
1892
1893 query.append(" AND ");
1894
1895 query.append("classPK = ?");
1896
1897 query.append(" AND ");
1898
1899 query.append("primary_ = ?");
1900
1901 query.append(" ");
1902
1903 if (obc != null) {
1904 query.append("ORDER BY ");
1905 query.append(obc.getOrderBy());
1906 }
1907
1908 else {
1909 query.append("ORDER BY ");
1910
1911 query.append("createDate ASC");
1912 }
1913
1914 Query q = session.createQuery(query.toString());
1915
1916 QueryPos qPos = QueryPos.getInstance(q);
1917
1918 qPos.add(companyId);
1919
1920 qPos.add(classNameId);
1921
1922 qPos.add(classPK);
1923
1924 qPos.add(primary);
1925
1926 Object[] objArray = QueryUtil.getPrevAndNext(q, count, obc, address);
1927
1928 Address[] array = new AddressImpl[3];
1929
1930 array[0] = (Address)objArray[0];
1931 array[1] = (Address)objArray[1];
1932 array[2] = (Address)objArray[2];
1933
1934 return array;
1935 }
1936 catch (Exception e) {
1937 throw processException(e);
1938 }
1939 finally {
1940 closeSession(session);
1941 }
1942 }
1943
1944 public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery)
1945 throws SystemException {
1946 Session session = null;
1947
1948 try {
1949 session = openSession();
1950
1951 dynamicQuery.compile(session);
1952
1953 return dynamicQuery.list();
1954 }
1955 catch (Exception e) {
1956 throw processException(e);
1957 }
1958 finally {
1959 closeSession(session);
1960 }
1961 }
1962
1963 public List<Object> findWithDynamicQuery(DynamicQuery dynamicQuery,
1964 int start, int end) throws SystemException {
1965 Session session = null;
1966
1967 try {
1968 session = openSession();
1969
1970 dynamicQuery.setLimit(start, end);
1971
1972 dynamicQuery.compile(session);
1973
1974 return dynamicQuery.list();
1975 }
1976 catch (Exception e) {
1977 throw processException(e);
1978 }
1979 finally {
1980 closeSession(session);
1981 }
1982 }
1983
1984 public List<Address> findAll() throws SystemException {
1985 return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1986 }
1987
1988 public List<Address> findAll(int start, int end) throws SystemException {
1989 return findAll(start, end, null);
1990 }
1991
1992 public List<Address> findAll(int start, int end, OrderByComparator obc)
1993 throws SystemException {
1994 boolean finderClassNameCacheEnabled = AddressModelImpl.CACHE_ENABLED;
1995 String finderClassName = Address.class.getName();
1996 String finderMethodName = "findAll";
1997 String[] finderParams = new String[] {
1998 "java.lang.Integer", "java.lang.Integer",
1999 "com.liferay.portal.kernel.util.OrderByComparator"
2000 };
2001 Object[] finderArgs = new Object[] {
2002 String.valueOf(start), String.valueOf(end), String.valueOf(obc)
2003 };
2004
2005 Object result = null;
2006
2007 if (finderClassNameCacheEnabled) {
2008 result = FinderCacheUtil.getResult(finderClassName,
2009 finderMethodName, finderParams, finderArgs, this);
2010 }
2011
2012 if (result == null) {
2013 Session session = null;
2014
2015 try {
2016 session = openSession();
2017
2018 StringBuilder query = new StringBuilder();
2019
2020 query.append("FROM com.liferay.portal.model.Address ");
2021
2022 if (obc != null) {
2023 query.append("ORDER BY ");
2024 query.append(obc.getOrderBy());
2025 }
2026
2027 else {
2028 query.append("ORDER BY ");
2029
2030 query.append("createDate ASC");
2031 }
2032
2033 Query q = session.createQuery(query.toString());
2034
2035 List<Address> list = (List<Address>)QueryUtil.list(q,
2036 getDialect(), start, end);
2037
2038 if (obc == null) {
2039 Collections.sort(list);
2040 }
2041
2042 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
2043 finderClassName, finderMethodName, finderParams,
2044 finderArgs, list);
2045
2046 return list;
2047 }
2048 catch (Exception e) {
2049 throw processException(e);
2050 }
2051 finally {
2052 closeSession(session);
2053 }
2054 }
2055 else {
2056 return (List<Address>)result;
2057 }
2058 }
2059
2060 public void removeByCompanyId(long companyId) throws SystemException {
2061 for (Address address : findByCompanyId(companyId)) {
2062 remove(address);
2063 }
2064 }
2065
2066 public void removeByUserId(long userId) throws SystemException {
2067 for (Address address : findByUserId(userId)) {
2068 remove(address);
2069 }
2070 }
2071
2072 public void removeByC_C(long companyId, long classNameId)
2073 throws SystemException {
2074 for (Address address : findByC_C(companyId, classNameId)) {
2075 remove(address);
2076 }
2077 }
2078
2079 public void removeByC_C_C(long companyId, long classNameId, long classPK)
2080 throws SystemException {
2081 for (Address address : findByC_C_C(companyId, classNameId, classPK)) {
2082 remove(address);
2083 }
2084 }
2085
2086 public void removeByC_C_C_M(long companyId, long classNameId, long classPK,
2087 boolean mailing) throws SystemException {
2088 for (Address address : findByC_C_C_M(companyId, classNameId, classPK,
2089 mailing)) {
2090 remove(address);
2091 }
2092 }
2093
2094 public void removeByC_C_C_P(long companyId, long classNameId, long classPK,
2095 boolean primary) throws SystemException {
2096 for (Address address : findByC_C_C_P(companyId, classNameId, classPK,
2097 primary)) {
2098 remove(address);
2099 }
2100 }
2101
2102 public void removeAll() throws SystemException {
2103 for (Address address : findAll()) {
2104 remove(address);
2105 }
2106 }
2107
2108 public int countByCompanyId(long companyId) throws SystemException {
2109 boolean finderClassNameCacheEnabled = AddressModelImpl.CACHE_ENABLED;
2110 String finderClassName = Address.class.getName();
2111 String finderMethodName = "countByCompanyId";
2112 String[] finderParams = new String[] { Long.class.getName() };
2113 Object[] finderArgs = new Object[] { new Long(companyId) };
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("FROM com.liferay.portal.model.Address WHERE ");
2132
2133 query.append("companyId = ?");
2134
2135 query.append(" ");
2136
2137 Query q = session.createQuery(query.toString());
2138
2139 QueryPos qPos = QueryPos.getInstance(q);
2140
2141 qPos.add(companyId);
2142
2143 Long count = null;
2144
2145 Iterator<Long> itr = q.list().iterator();
2146
2147 if (itr.hasNext()) {
2148 count = itr.next();
2149 }
2150
2151 if (count == null) {
2152 count = new Long(0);
2153 }
2154
2155 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
2156 finderClassName, finderMethodName, finderParams,
2157 finderArgs, count);
2158
2159 return count.intValue();
2160 }
2161 catch (Exception e) {
2162 throw processException(e);
2163 }
2164 finally {
2165 closeSession(session);
2166 }
2167 }
2168 else {
2169 return ((Long)result).intValue();
2170 }
2171 }
2172
2173 public int countByUserId(long userId) throws SystemException {
2174 boolean finderClassNameCacheEnabled = AddressModelImpl.CACHE_ENABLED;
2175 String finderClassName = Address.class.getName();
2176 String finderMethodName = "countByUserId";
2177 String[] finderParams = new String[] { Long.class.getName() };
2178 Object[] finderArgs = new Object[] { new Long(userId) };
2179
2180 Object result = null;
2181
2182 if (finderClassNameCacheEnabled) {
2183 result = FinderCacheUtil.getResult(finderClassName,
2184 finderMethodName, finderParams, finderArgs, this);
2185 }
2186
2187 if (result == null) {
2188 Session session = null;
2189
2190 try {
2191 session = openSession();
2192
2193 StringBuilder query = new StringBuilder();
2194
2195 query.append("SELECT COUNT(*) ");
2196 query.append("FROM com.liferay.portal.model.Address WHERE ");
2197
2198 query.append("userId = ?");
2199
2200 query.append(" ");
2201
2202 Query q = session.createQuery(query.toString());
2203
2204 QueryPos qPos = QueryPos.getInstance(q);
2205
2206 qPos.add(userId);
2207
2208 Long count = null;
2209
2210 Iterator<Long> itr = q.list().iterator();
2211
2212 if (itr.hasNext()) {
2213 count = itr.next();
2214 }
2215
2216 if (count == null) {
2217 count = new Long(0);
2218 }
2219
2220 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
2221 finderClassName, finderMethodName, finderParams,
2222 finderArgs, count);
2223
2224 return count.intValue();
2225 }
2226 catch (Exception e) {
2227 throw processException(e);
2228 }
2229 finally {
2230 closeSession(session);
2231 }
2232 }
2233 else {
2234 return ((Long)result).intValue();
2235 }
2236 }
2237
2238 public int countByC_C(long companyId, long classNameId)
2239 throws SystemException {
2240 boolean finderClassNameCacheEnabled = AddressModelImpl.CACHE_ENABLED;
2241 String finderClassName = Address.class.getName();
2242 String finderMethodName = "countByC_C";
2243 String[] finderParams = new String[] {
2244 Long.class.getName(), Long.class.getName()
2245 };
2246 Object[] finderArgs = new Object[] {
2247 new Long(companyId), new Long(classNameId)
2248 };
2249
2250 Object result = null;
2251
2252 if (finderClassNameCacheEnabled) {
2253 result = FinderCacheUtil.getResult(finderClassName,
2254 finderMethodName, finderParams, finderArgs, this);
2255 }
2256
2257 if (result == null) {
2258 Session session = null;
2259
2260 try {
2261 session = openSession();
2262
2263 StringBuilder query = new StringBuilder();
2264
2265 query.append("SELECT COUNT(*) ");
2266 query.append("FROM com.liferay.portal.model.Address WHERE ");
2267
2268 query.append("companyId = ?");
2269
2270 query.append(" AND ");
2271
2272 query.append("classNameId = ?");
2273
2274 query.append(" ");
2275
2276 Query q = session.createQuery(query.toString());
2277
2278 QueryPos qPos = QueryPos.getInstance(q);
2279
2280 qPos.add(companyId);
2281
2282 qPos.add(classNameId);
2283
2284 Long count = null;
2285
2286 Iterator<Long> itr = q.list().iterator();
2287
2288 if (itr.hasNext()) {
2289 count = itr.next();
2290 }
2291
2292 if (count == null) {
2293 count = new Long(0);
2294 }
2295
2296 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
2297 finderClassName, finderMethodName, finderParams,
2298 finderArgs, count);
2299
2300 return count.intValue();
2301 }
2302 catch (Exception e) {
2303 throw processException(e);
2304 }
2305 finally {
2306 closeSession(session);
2307 }
2308 }
2309 else {
2310 return ((Long)result).intValue();
2311 }
2312 }
2313
2314 public int countByC_C_C(long companyId, long classNameId, long classPK)
2315 throws SystemException {
2316 boolean finderClassNameCacheEnabled = AddressModelImpl.CACHE_ENABLED;
2317 String finderClassName = Address.class.getName();
2318 String finderMethodName = "countByC_C_C";
2319 String[] finderParams = new String[] {
2320 Long.class.getName(), Long.class.getName(), Long.class.getName()
2321 };
2322 Object[] finderArgs = new Object[] {
2323 new Long(companyId), new Long(classNameId), new Long(classPK)
2324 };
2325
2326 Object result = null;
2327
2328 if (finderClassNameCacheEnabled) {
2329 result = FinderCacheUtil.getResult(finderClassName,
2330 finderMethodName, finderParams, finderArgs, this);
2331 }
2332
2333 if (result == null) {
2334 Session session = null;
2335
2336 try {
2337 session = openSession();
2338
2339 StringBuilder query = new StringBuilder();
2340
2341 query.append("SELECT COUNT(*) ");
2342 query.append("FROM com.liferay.portal.model.Address WHERE ");
2343
2344 query.append("companyId = ?");
2345
2346 query.append(" AND ");
2347
2348 query.append("classNameId = ?");
2349
2350 query.append(" AND ");
2351
2352 query.append("classPK = ?");
2353
2354 query.append(" ");
2355
2356 Query q = session.createQuery(query.toString());
2357
2358 QueryPos qPos = QueryPos.getInstance(q);
2359
2360 qPos.add(companyId);
2361
2362 qPos.add(classNameId);
2363
2364 qPos.add(classPK);
2365
2366 Long count = null;
2367
2368 Iterator<Long> itr = q.list().iterator();
2369
2370 if (itr.hasNext()) {
2371 count = itr.next();
2372 }
2373
2374 if (count == null) {
2375 count = new Long(0);
2376 }
2377
2378 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
2379 finderClassName, finderMethodName, finderParams,
2380 finderArgs, count);
2381
2382 return count.intValue();
2383 }
2384 catch (Exception e) {
2385 throw processException(e);
2386 }
2387 finally {
2388 closeSession(session);
2389 }
2390 }
2391 else {
2392 return ((Long)result).intValue();
2393 }
2394 }
2395
2396 public int countByC_C_C_M(long companyId, long classNameId, long classPK,
2397 boolean mailing) throws SystemException {
2398 boolean finderClassNameCacheEnabled = AddressModelImpl.CACHE_ENABLED;
2399 String finderClassName = Address.class.getName();
2400 String finderMethodName = "countByC_C_C_M";
2401 String[] finderParams = new String[] {
2402 Long.class.getName(), Long.class.getName(), Long.class.getName(),
2403 Boolean.class.getName()
2404 };
2405 Object[] finderArgs = new Object[] {
2406 new Long(companyId), new Long(classNameId), new Long(classPK),
2407 Boolean.valueOf(mailing)
2408 };
2409
2410 Object result = null;
2411
2412 if (finderClassNameCacheEnabled) {
2413 result = FinderCacheUtil.getResult(finderClassName,
2414 finderMethodName, finderParams, finderArgs, this);
2415 }
2416
2417 if (result == null) {
2418 Session session = null;
2419
2420 try {
2421 session = openSession();
2422
2423 StringBuilder query = new StringBuilder();
2424
2425 query.append("SELECT COUNT(*) ");
2426 query.append("FROM com.liferay.portal.model.Address WHERE ");
2427
2428 query.append("companyId = ?");
2429
2430 query.append(" AND ");
2431
2432 query.append("classNameId = ?");
2433
2434 query.append(" AND ");
2435
2436 query.append("classPK = ?");
2437
2438 query.append(" AND ");
2439
2440 query.append("mailing = ?");
2441
2442 query.append(" ");
2443
2444 Query q = session.createQuery(query.toString());
2445
2446 QueryPos qPos = QueryPos.getInstance(q);
2447
2448 qPos.add(companyId);
2449
2450 qPos.add(classNameId);
2451
2452 qPos.add(classPK);
2453
2454 qPos.add(mailing);
2455
2456 Long count = null;
2457
2458 Iterator<Long> itr = q.list().iterator();
2459
2460 if (itr.hasNext()) {
2461 count = itr.next();
2462 }
2463
2464 if (count == null) {
2465 count = new Long(0);
2466 }
2467
2468 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
2469 finderClassName, finderMethodName, finderParams,
2470 finderArgs, count);
2471
2472 return count.intValue();
2473 }
2474 catch (Exception e) {
2475 throw processException(e);
2476 }
2477 finally {
2478 closeSession(session);
2479 }
2480 }
2481 else {
2482 return ((Long)result).intValue();
2483 }
2484 }
2485
2486 public int countByC_C_C_P(long companyId, long classNameId, long classPK,
2487 boolean primary) throws SystemException {
2488 boolean finderClassNameCacheEnabled = AddressModelImpl.CACHE_ENABLED;
2489 String finderClassName = Address.class.getName();
2490 String finderMethodName = "countByC_C_C_P";
2491 String[] finderParams = new String[] {
2492 Long.class.getName(), Long.class.getName(), Long.class.getName(),
2493 Boolean.class.getName()
2494 };
2495 Object[] finderArgs = new Object[] {
2496 new Long(companyId), new Long(classNameId), new Long(classPK),
2497 Boolean.valueOf(primary)
2498 };
2499
2500 Object result = null;
2501
2502 if (finderClassNameCacheEnabled) {
2503 result = FinderCacheUtil.getResult(finderClassName,
2504 finderMethodName, finderParams, finderArgs, this);
2505 }
2506
2507 if (result == null) {
2508 Session session = null;
2509
2510 try {
2511 session = openSession();
2512
2513 StringBuilder query = new StringBuilder();
2514
2515 query.append("SELECT COUNT(*) ");
2516 query.append("FROM com.liferay.portal.model.Address WHERE ");
2517
2518 query.append("companyId = ?");
2519
2520 query.append(" AND ");
2521
2522 query.append("classNameId = ?");
2523
2524 query.append(" AND ");
2525
2526 query.append("classPK = ?");
2527
2528 query.append(" AND ");
2529
2530 query.append("primary_ = ?");
2531
2532 query.append(" ");
2533
2534 Query q = session.createQuery(query.toString());
2535
2536 QueryPos qPos = QueryPos.getInstance(q);
2537
2538 qPos.add(companyId);
2539
2540 qPos.add(classNameId);
2541
2542 qPos.add(classPK);
2543
2544 qPos.add(primary);
2545
2546 Long count = null;
2547
2548 Iterator<Long> itr = q.list().iterator();
2549
2550 if (itr.hasNext()) {
2551 count = itr.next();
2552 }
2553
2554 if (count == null) {
2555 count = new Long(0);
2556 }
2557
2558 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
2559 finderClassName, finderMethodName, finderParams,
2560 finderArgs, count);
2561
2562 return count.intValue();
2563 }
2564 catch (Exception e) {
2565 throw processException(e);
2566 }
2567 finally {
2568 closeSession(session);
2569 }
2570 }
2571 else {
2572 return ((Long)result).intValue();
2573 }
2574 }
2575
2576 public int countAll() throws SystemException {
2577 boolean finderClassNameCacheEnabled = AddressModelImpl.CACHE_ENABLED;
2578 String finderClassName = Address.class.getName();
2579 String finderMethodName = "countAll";
2580 String[] finderParams = new String[] { };
2581 Object[] finderArgs = new Object[] { };
2582
2583 Object result = null;
2584
2585 if (finderClassNameCacheEnabled) {
2586 result = FinderCacheUtil.getResult(finderClassName,
2587 finderMethodName, finderParams, finderArgs, this);
2588 }
2589
2590 if (result == null) {
2591 Session session = null;
2592
2593 try {
2594 session = openSession();
2595
2596 Query q = session.createQuery(
2597 "SELECT COUNT(*) FROM com.liferay.portal.model.Address");
2598
2599 Long count = null;
2600
2601 Iterator<Long> itr = q.list().iterator();
2602
2603 if (itr.hasNext()) {
2604 count = itr.next();
2605 }
2606
2607 if (count == null) {
2608 count = new Long(0);
2609 }
2610
2611 FinderCacheUtil.putResult(finderClassNameCacheEnabled,
2612 finderClassName, finderMethodName, finderParams,
2613 finderArgs, count);
2614
2615 return count.intValue();
2616 }
2617 catch (Exception e) {
2618 throw processException(e);
2619 }
2620 finally {
2621 closeSession(session);
2622 }
2623 }
2624 else {
2625 return ((Long)result).intValue();
2626 }
2627 }
2628
2629 public void registerListener(ModelListener listener) {
2630 List<ModelListener> listeners = ListUtil.fromArray(_listeners);
2631
2632 listeners.add(listener);
2633
2634 _listeners = listeners.toArray(new ModelListener[listeners.size()]);
2635 }
2636
2637 public void unregisterListener(ModelListener listener) {
2638 List<ModelListener> listeners = ListUtil.fromArray(_listeners);
2639
2640 listeners.remove(listener);
2641
2642 _listeners = listeners.toArray(new ModelListener[listeners.size()]);
2643 }
2644
2645 public void afterPropertiesSet() {
2646 String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
2647 com.liferay.portal.util.PropsUtil.get(
2648 "value.object.listener.com.liferay.portal.model.Address")));
2649
2650 if (listenerClassNames.length > 0) {
2651 try {
2652 List<ModelListener> listeners = new ArrayList<ModelListener>();
2653
2654 for (String listenerClassName : listenerClassNames) {
2655 listeners.add((ModelListener)Class.forName(
2656 listenerClassName).newInstance());
2657 }
2658
2659 _listeners = listeners.toArray(new ModelListener[listeners.size()]);
2660 }
2661 catch (Exception e) {
2662 _log.error(e);
2663 }
2664 }
2665 }
2666
2667 private static Log _log = LogFactory.getLog(AddressPersistenceImpl.class);
2668 private ModelListener[] _listeners = new ModelListener[0];
2669}