1
14
15 package com.liferay.portal.service.persistence;
16
17 import com.liferay.portal.NoSuchModelException;
18 import com.liferay.portal.NoSuchOrganizationException;
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.jdbc.MappingSqlQuery;
23 import com.liferay.portal.kernel.dao.jdbc.MappingSqlQueryFactoryUtil;
24 import com.liferay.portal.kernel.dao.jdbc.RowMapper;
25 import com.liferay.portal.kernel.dao.jdbc.SqlUpdate;
26 import com.liferay.portal.kernel.dao.jdbc.SqlUpdateFactoryUtil;
27 import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
28 import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
29 import com.liferay.portal.kernel.dao.orm.FinderPath;
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.SQLQuery;
34 import com.liferay.portal.kernel.dao.orm.Session;
35 import com.liferay.portal.kernel.log.Log;
36 import com.liferay.portal.kernel.log.LogFactoryUtil;
37 import com.liferay.portal.kernel.util.GetterUtil;
38 import com.liferay.portal.kernel.util.InstanceFactory;
39 import com.liferay.portal.kernel.util.OrderByComparator;
40 import com.liferay.portal.kernel.util.SetUtil;
41 import com.liferay.portal.kernel.util.StringBundler;
42 import com.liferay.portal.kernel.util.StringPool;
43 import com.liferay.portal.kernel.util.StringUtil;
44 import com.liferay.portal.kernel.util.Validator;
45 import com.liferay.portal.model.ModelListener;
46 import com.liferay.portal.model.Organization;
47 import com.liferay.portal.model.impl.OrganizationImpl;
48 import com.liferay.portal.model.impl.OrganizationModelImpl;
49 import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
50
51 import com.liferay.portlet.expando.service.persistence.ExpandoValuePersistence;
52 import com.liferay.portlet.tags.service.persistence.TagsAssetPersistence;
53
54 import java.io.Serializable;
55
56 import java.util.ArrayList;
57 import java.util.Collections;
58 import java.util.List;
59 import java.util.Set;
60
61
74 public class OrganizationPersistenceImpl extends BasePersistenceImpl<Organization>
75 implements OrganizationPersistence {
76 public static final String FINDER_CLASS_NAME_ENTITY = OrganizationImpl.class.getName();
77 public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
78 ".List";
79 public static final FinderPath FINDER_PATH_FIND_BY_COMPANYID = new FinderPath(OrganizationModelImpl.ENTITY_CACHE_ENABLED,
80 OrganizationModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
81 "findByCompanyId",
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_COMPANYID = new FinderPath(OrganizationModelImpl.ENTITY_CACHE_ENABLED,
89 OrganizationModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
90 "countByCompanyId", new String[] { Long.class.getName() });
91 public static final FinderPath FINDER_PATH_FIND_BY_LOCATIONS = new FinderPath(OrganizationModelImpl.ENTITY_CACHE_ENABLED,
92 OrganizationModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
93 "findByLocations",
94 new String[] {
95 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_LOCATIONS = new FinderPath(OrganizationModelImpl.ENTITY_CACHE_ENABLED,
101 OrganizationModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
102 "countByLocations", new String[] { Long.class.getName() });
103 public static final FinderPath FINDER_PATH_FIND_BY_C_P = new FinderPath(OrganizationModelImpl.ENTITY_CACHE_ENABLED,
104 OrganizationModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
105 "findByC_P",
106 new String[] {
107 Long.class.getName(), Long.class.getName(),
108
109 "java.lang.Integer", "java.lang.Integer",
110 "com.liferay.portal.kernel.util.OrderByComparator"
111 });
112 public static final FinderPath FINDER_PATH_COUNT_BY_C_P = new FinderPath(OrganizationModelImpl.ENTITY_CACHE_ENABLED,
113 OrganizationModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
114 "countByC_P",
115 new String[] { Long.class.getName(), Long.class.getName() });
116 public static final FinderPath FINDER_PATH_FETCH_BY_C_N = new FinderPath(OrganizationModelImpl.ENTITY_CACHE_ENABLED,
117 OrganizationModelImpl.FINDER_CACHE_ENABLED,
118 FINDER_CLASS_NAME_ENTITY, "fetchByC_N",
119 new String[] { Long.class.getName(), String.class.getName() });
120 public static final FinderPath FINDER_PATH_COUNT_BY_C_N = new FinderPath(OrganizationModelImpl.ENTITY_CACHE_ENABLED,
121 OrganizationModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
122 "countByC_N",
123 new String[] { Long.class.getName(), String.class.getName() });
124 public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(OrganizationModelImpl.ENTITY_CACHE_ENABLED,
125 OrganizationModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
126 "findAll", new String[0]);
127 public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(OrganizationModelImpl.ENTITY_CACHE_ENABLED,
128 OrganizationModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
129 "countAll", new String[0]);
130
131 public void cacheResult(Organization organization) {
132 EntityCacheUtil.putResult(OrganizationModelImpl.ENTITY_CACHE_ENABLED,
133 OrganizationImpl.class, organization.getPrimaryKey(), organization);
134
135 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_N,
136 new Object[] {
137 new Long(organization.getCompanyId()),
138
139 organization.getName()
140 }, organization);
141 }
142
143 public void cacheResult(List<Organization> organizations) {
144 for (Organization organization : organizations) {
145 if (EntityCacheUtil.getResult(
146 OrganizationModelImpl.ENTITY_CACHE_ENABLED,
147 OrganizationImpl.class, organization.getPrimaryKey(),
148 this) == null) {
149 cacheResult(organization);
150 }
151 }
152 }
153
154 public void clearCache() {
155 CacheRegistry.clear(OrganizationImpl.class.getName());
156 EntityCacheUtil.clearCache(OrganizationImpl.class.getName());
157 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
158 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
159 }
160
161 public void clearCache(Organization organization) {
162 EntityCacheUtil.removeResult(OrganizationModelImpl.ENTITY_CACHE_ENABLED,
163 OrganizationImpl.class, organization.getPrimaryKey());
164
165 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_N,
166 new Object[] {
167 new Long(organization.getCompanyId()),
168
169 organization.getName()
170 });
171 }
172
173 public Organization create(long organizationId) {
174 Organization organization = new OrganizationImpl();
175
176 organization.setNew(true);
177 organization.setPrimaryKey(organizationId);
178
179 return organization;
180 }
181
182 public Organization remove(Serializable primaryKey)
183 throws NoSuchModelException, SystemException {
184 return remove(((Long)primaryKey).longValue());
185 }
186
187 public Organization remove(long organizationId)
188 throws NoSuchOrganizationException, SystemException {
189 Session session = null;
190
191 try {
192 session = openSession();
193
194 Organization organization = (Organization)session.get(OrganizationImpl.class,
195 new Long(organizationId));
196
197 if (organization == null) {
198 if (_log.isWarnEnabled()) {
199 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
200 organizationId);
201 }
202
203 throw new NoSuchOrganizationException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
204 organizationId);
205 }
206
207 return remove(organization);
208 }
209 catch (NoSuchOrganizationException nsee) {
210 throw nsee;
211 }
212 catch (Exception e) {
213 throw processException(e);
214 }
215 finally {
216 closeSession(session);
217 }
218 }
219
220 protected Organization removeImpl(Organization organization)
221 throws SystemException {
222 organization = toUnwrappedModel(organization);
223
224 try {
225 clearGroups.clear(organization.getPrimaryKey());
226 }
227 catch (Exception e) {
228 throw processException(e);
229 }
230 finally {
231 FinderCacheUtil.clearCache(OrganizationModelImpl.MAPPING_TABLE_GROUPS_ORGS_NAME);
232 }
233
234 try {
235 clearUsers.clear(organization.getPrimaryKey());
236 }
237 catch (Exception e) {
238 throw processException(e);
239 }
240 finally {
241 FinderCacheUtil.clearCache(OrganizationModelImpl.MAPPING_TABLE_USERS_ORGS_NAME);
242 }
243
244 shrinkTree(organization);
245
246 Session session = null;
247
248 try {
249 session = openSession();
250
251 BatchSessionUtil.delete(session, organization);
252 }
253 catch (Exception e) {
254 throw processException(e);
255 }
256 finally {
257 closeSession(session);
258 }
259
260 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
261
262 OrganizationModelImpl organizationModelImpl = (OrganizationModelImpl)organization;
263
264 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_N,
265 new Object[] {
266 new Long(organizationModelImpl.getOriginalCompanyId()),
267
268 organizationModelImpl.getOriginalName()
269 });
270
271 EntityCacheUtil.removeResult(OrganizationModelImpl.ENTITY_CACHE_ENABLED,
272 OrganizationImpl.class, organization.getPrimaryKey());
273
274 return organization;
275 }
276
277
280 public Organization update(Organization organization)
281 throws SystemException {
282 if (_log.isWarnEnabled()) {
283 _log.warn(
284 "Using the deprecated update(Organization organization) method. Use update(Organization organization, boolean merge) instead.");
285 }
286
287 return update(organization, false);
288 }
289
290 public Organization updateImpl(
291 com.liferay.portal.model.Organization organization, boolean merge)
292 throws SystemException {
293 organization = toUnwrappedModel(organization);
294
295 boolean isNew = organization.isNew();
296
297 OrganizationModelImpl organizationModelImpl = (OrganizationModelImpl)organization;
298
299 if (isNew) {
300 expandTree(organization);
301 }
302 else {
303 if (organization.getParentOrganizationId() != organizationModelImpl.getOriginalParentOrganizationId()) {
304 shrinkTree(organization);
305 expandTree(organization);
306 }
307 }
308
309 Session session = null;
310
311 try {
312 session = openSession();
313
314 BatchSessionUtil.update(session, organization, merge);
315
316 organization.setNew(false);
317 }
318 catch (Exception e) {
319 throw processException(e);
320 }
321 finally {
322 closeSession(session);
323 }
324
325 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
326
327 EntityCacheUtil.putResult(OrganizationModelImpl.ENTITY_CACHE_ENABLED,
328 OrganizationImpl.class, organization.getPrimaryKey(), organization);
329
330 if (!isNew &&
331 ((organization.getCompanyId() != organizationModelImpl.getOriginalCompanyId()) ||
332 !Validator.equals(organization.getName(),
333 organizationModelImpl.getOriginalName()))) {
334 FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_N,
335 new Object[] {
336 new Long(organizationModelImpl.getOriginalCompanyId()),
337
338 organizationModelImpl.getOriginalName()
339 });
340 }
341
342 if (isNew ||
343 ((organization.getCompanyId() != organizationModelImpl.getOriginalCompanyId()) ||
344 !Validator.equals(organization.getName(),
345 organizationModelImpl.getOriginalName()))) {
346 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_N,
347 new Object[] {
348 new Long(organization.getCompanyId()),
349
350 organization.getName()
351 }, organization);
352 }
353
354 return organization;
355 }
356
357 protected Organization toUnwrappedModel(Organization organization) {
358 if (organization instanceof OrganizationImpl) {
359 return organization;
360 }
361
362 OrganizationImpl organizationImpl = new OrganizationImpl();
363
364 organizationImpl.setNew(organization.isNew());
365 organizationImpl.setPrimaryKey(organization.getPrimaryKey());
366
367 organizationImpl.setOrganizationId(organization.getOrganizationId());
368 organizationImpl.setCompanyId(organization.getCompanyId());
369 organizationImpl.setParentOrganizationId(organization.getParentOrganizationId());
370 organizationImpl.setLeftOrganizationId(organization.getLeftOrganizationId());
371 organizationImpl.setRightOrganizationId(organization.getRightOrganizationId());
372 organizationImpl.setName(organization.getName());
373 organizationImpl.setType(organization.getType());
374 organizationImpl.setRecursable(organization.isRecursable());
375 organizationImpl.setRegionId(organization.getRegionId());
376 organizationImpl.setCountryId(organization.getCountryId());
377 organizationImpl.setStatusId(organization.getStatusId());
378 organizationImpl.setComments(organization.getComments());
379
380 return organizationImpl;
381 }
382
383 public Organization findByPrimaryKey(Serializable primaryKey)
384 throws NoSuchModelException, SystemException {
385 return findByPrimaryKey(((Long)primaryKey).longValue());
386 }
387
388 public Organization findByPrimaryKey(long organizationId)
389 throws NoSuchOrganizationException, SystemException {
390 Organization organization = fetchByPrimaryKey(organizationId);
391
392 if (organization == null) {
393 if (_log.isWarnEnabled()) {
394 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + organizationId);
395 }
396
397 throw new NoSuchOrganizationException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
398 organizationId);
399 }
400
401 return organization;
402 }
403
404 public Organization fetchByPrimaryKey(Serializable primaryKey)
405 throws SystemException {
406 return fetchByPrimaryKey(((Long)primaryKey).longValue());
407 }
408
409 public Organization fetchByPrimaryKey(long organizationId)
410 throws SystemException {
411 Organization organization = (Organization)EntityCacheUtil.getResult(OrganizationModelImpl.ENTITY_CACHE_ENABLED,
412 OrganizationImpl.class, organizationId, this);
413
414 if (organization == null) {
415 Session session = null;
416
417 try {
418 session = openSession();
419
420 organization = (Organization)session.get(OrganizationImpl.class,
421 new Long(organizationId));
422 }
423 catch (Exception e) {
424 throw processException(e);
425 }
426 finally {
427 if (organization != null) {
428 cacheResult(organization);
429 }
430
431 closeSession(session);
432 }
433 }
434
435 return organization;
436 }
437
438 public List<Organization> findByCompanyId(long companyId)
439 throws SystemException {
440 return findByCompanyId(companyId, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
441 null);
442 }
443
444 public List<Organization> findByCompanyId(long companyId, int start, int end)
445 throws SystemException {
446 return findByCompanyId(companyId, start, end, null);
447 }
448
449 public List<Organization> findByCompanyId(long companyId, int start,
450 int end, OrderByComparator orderByComparator) throws SystemException {
451 Object[] finderArgs = new Object[] {
452 companyId,
453
454 String.valueOf(start), String.valueOf(end),
455 String.valueOf(orderByComparator)
456 };
457
458 List<Organization> list = (List<Organization>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_COMPANYID,
459 finderArgs, this);
460
461 if (list == null) {
462 StringBundler query = null;
463
464 if (orderByComparator != null) {
465 query = new StringBundler(3 +
466 (orderByComparator.getOrderByFields().length * 3));
467 }
468 else {
469 query = new StringBundler(3);
470 }
471
472 query.append(_SQL_SELECT_ORGANIZATION_WHERE);
473
474 query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
475
476 if (orderByComparator != null) {
477 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
478 orderByComparator);
479 }
480
481 else {
482 query.append(OrganizationModelImpl.ORDER_BY_JPQL);
483 }
484
485 String sql = query.toString();
486
487 Session session = null;
488
489 try {
490 session = openSession();
491
492 Query q = session.createQuery(sql);
493
494 QueryPos qPos = QueryPos.getInstance(q);
495
496 qPos.add(companyId);
497
498 list = (List<Organization>)QueryUtil.list(q, getDialect(),
499 start, end);
500 }
501 catch (Exception e) {
502 throw processException(e);
503 }
504 finally {
505 if (list == null) {
506 list = new ArrayList<Organization>();
507 }
508
509 cacheResult(list);
510
511 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_COMPANYID,
512 finderArgs, list);
513
514 closeSession(session);
515 }
516 }
517
518 return list;
519 }
520
521 public Organization findByCompanyId_First(long companyId,
522 OrderByComparator orderByComparator)
523 throws NoSuchOrganizationException, SystemException {
524 List<Organization> list = findByCompanyId(companyId, 0, 1,
525 orderByComparator);
526
527 if (list.isEmpty()) {
528 StringBundler msg = new StringBundler(4);
529
530 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
531
532 msg.append("companyId=");
533 msg.append(companyId);
534
535 msg.append(StringPool.CLOSE_CURLY_BRACE);
536
537 throw new NoSuchOrganizationException(msg.toString());
538 }
539 else {
540 return list.get(0);
541 }
542 }
543
544 public Organization findByCompanyId_Last(long companyId,
545 OrderByComparator orderByComparator)
546 throws NoSuchOrganizationException, SystemException {
547 int count = countByCompanyId(companyId);
548
549 List<Organization> list = findByCompanyId(companyId, count - 1, count,
550 orderByComparator);
551
552 if (list.isEmpty()) {
553 StringBundler msg = new StringBundler(4);
554
555 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
556
557 msg.append("companyId=");
558 msg.append(companyId);
559
560 msg.append(StringPool.CLOSE_CURLY_BRACE);
561
562 throw new NoSuchOrganizationException(msg.toString());
563 }
564 else {
565 return list.get(0);
566 }
567 }
568
569 public Organization[] findByCompanyId_PrevAndNext(long organizationId,
570 long companyId, OrderByComparator orderByComparator)
571 throws NoSuchOrganizationException, SystemException {
572 Organization organization = findByPrimaryKey(organizationId);
573
574 Session session = null;
575
576 try {
577 session = openSession();
578
579 Organization[] array = new OrganizationImpl[3];
580
581 array[0] = getByCompanyId_PrevAndNext(session, organization,
582 companyId, orderByComparator, true);
583
584 array[1] = organization;
585
586 array[2] = getByCompanyId_PrevAndNext(session, organization,
587 companyId, orderByComparator, false);
588
589 return array;
590 }
591 catch (Exception e) {
592 throw processException(e);
593 }
594 finally {
595 closeSession(session);
596 }
597 }
598
599 protected Organization getByCompanyId_PrevAndNext(Session session,
600 Organization organization, long companyId,
601 OrderByComparator orderByComparator, boolean previous) {
602 StringBundler query = null;
603
604 if (orderByComparator != null) {
605 query = new StringBundler(6 +
606 (orderByComparator.getOrderByFields().length * 6));
607 }
608 else {
609 query = new StringBundler(3);
610 }
611
612 query.append(_SQL_SELECT_ORGANIZATION_WHERE);
613
614 query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
615
616 if (orderByComparator != null) {
617 String[] orderByFields = orderByComparator.getOrderByFields();
618
619 if (orderByFields.length > 0) {
620 query.append(WHERE_AND);
621 }
622
623 for (int i = 0; i < orderByFields.length; i++) {
624 query.append(_ORDER_BY_ENTITY_ALIAS);
625 query.append(orderByFields[i]);
626
627 if ((i + 1) < orderByFields.length) {
628 if (orderByComparator.isAscending() ^ previous) {
629 query.append(WHERE_GREATER_THAN_HAS_NEXT);
630 }
631 else {
632 query.append(WHERE_LESSER_THAN_HAS_NEXT);
633 }
634 }
635 else {
636 if (orderByComparator.isAscending() ^ previous) {
637 query.append(WHERE_GREATER_THAN);
638 }
639 else {
640 query.append(WHERE_LESSER_THAN);
641 }
642 }
643 }
644
645 query.append(ORDER_BY_CLAUSE);
646
647 for (int i = 0; i < orderByFields.length; i++) {
648 query.append(_ORDER_BY_ENTITY_ALIAS);
649 query.append(orderByFields[i]);
650
651 if ((i + 1) < orderByFields.length) {
652 if (orderByComparator.isAscending() ^ previous) {
653 query.append(ORDER_BY_ASC_HAS_NEXT);
654 }
655 else {
656 query.append(ORDER_BY_DESC_HAS_NEXT);
657 }
658 }
659 else {
660 if (orderByComparator.isAscending() ^ previous) {
661 query.append(ORDER_BY_ASC);
662 }
663 else {
664 query.append(ORDER_BY_DESC);
665 }
666 }
667 }
668 }
669
670 else {
671 query.append(OrganizationModelImpl.ORDER_BY_JPQL);
672 }
673
674 String sql = query.toString();
675
676 Query q = session.createQuery(sql);
677
678 q.setFirstResult(0);
679 q.setMaxResults(2);
680
681 QueryPos qPos = QueryPos.getInstance(q);
682
683 qPos.add(companyId);
684
685 if (orderByComparator != null) {
686 Object[] values = orderByComparator.getOrderByValues(organization);
687
688 for (Object value : values) {
689 qPos.add(value);
690 }
691 }
692
693 List<Organization> list = q.list();
694
695 if (list.size() == 2) {
696 return list.get(1);
697 }
698 else {
699 return null;
700 }
701 }
702
703 public List<Organization> findByLocations(long companyId)
704 throws SystemException {
705 return findByLocations(companyId, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
706 null);
707 }
708
709 public List<Organization> findByLocations(long companyId, int start, int end)
710 throws SystemException {
711 return findByLocations(companyId, start, end, null);
712 }
713
714 public List<Organization> findByLocations(long companyId, int start,
715 int end, OrderByComparator orderByComparator) throws SystemException {
716 Object[] finderArgs = new Object[] {
717 companyId,
718
719 String.valueOf(start), String.valueOf(end),
720 String.valueOf(orderByComparator)
721 };
722
723 List<Organization> list = (List<Organization>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_LOCATIONS,
724 finderArgs, this);
725
726 if (list == null) {
727 StringBundler query = null;
728
729 if (orderByComparator != null) {
730 query = new StringBundler(3 +
731 (orderByComparator.getOrderByFields().length * 3));
732 }
733 else {
734 query = new StringBundler(3);
735 }
736
737 query.append(_SQL_SELECT_ORGANIZATION_WHERE);
738
739 query.append(_FINDER_COLUMN_LOCATIONS_COMPANYID_2);
740
741 if (orderByComparator != null) {
742 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
743 orderByComparator);
744 }
745
746 else {
747 query.append(OrganizationModelImpl.ORDER_BY_JPQL);
748 }
749
750 String sql = query.toString();
751
752 Session session = null;
753
754 try {
755 session = openSession();
756
757 Query q = session.createQuery(sql);
758
759 QueryPos qPos = QueryPos.getInstance(q);
760
761 qPos.add(companyId);
762
763 list = (List<Organization>)QueryUtil.list(q, getDialect(),
764 start, end);
765 }
766 catch (Exception e) {
767 throw processException(e);
768 }
769 finally {
770 if (list == null) {
771 list = new ArrayList<Organization>();
772 }
773
774 cacheResult(list);
775
776 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_LOCATIONS,
777 finderArgs, list);
778
779 closeSession(session);
780 }
781 }
782
783 return list;
784 }
785
786 public Organization findByLocations_First(long companyId,
787 OrderByComparator orderByComparator)
788 throws NoSuchOrganizationException, SystemException {
789 List<Organization> list = findByLocations(companyId, 0, 1,
790 orderByComparator);
791
792 if (list.isEmpty()) {
793 StringBundler msg = new StringBundler(4);
794
795 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
796
797 msg.append("companyId=");
798 msg.append(companyId);
799
800 msg.append(StringPool.CLOSE_CURLY_BRACE);
801
802 throw new NoSuchOrganizationException(msg.toString());
803 }
804 else {
805 return list.get(0);
806 }
807 }
808
809 public Organization findByLocations_Last(long companyId,
810 OrderByComparator orderByComparator)
811 throws NoSuchOrganizationException, SystemException {
812 int count = countByLocations(companyId);
813
814 List<Organization> list = findByLocations(companyId, count - 1, count,
815 orderByComparator);
816
817 if (list.isEmpty()) {
818 StringBundler msg = new StringBundler(4);
819
820 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
821
822 msg.append("companyId=");
823 msg.append(companyId);
824
825 msg.append(StringPool.CLOSE_CURLY_BRACE);
826
827 throw new NoSuchOrganizationException(msg.toString());
828 }
829 else {
830 return list.get(0);
831 }
832 }
833
834 public Organization[] findByLocations_PrevAndNext(long organizationId,
835 long companyId, OrderByComparator orderByComparator)
836 throws NoSuchOrganizationException, SystemException {
837 Organization organization = findByPrimaryKey(organizationId);
838
839 Session session = null;
840
841 try {
842 session = openSession();
843
844 Organization[] array = new OrganizationImpl[3];
845
846 array[0] = getByLocations_PrevAndNext(session, organization,
847 companyId, orderByComparator, true);
848
849 array[1] = organization;
850
851 array[2] = getByLocations_PrevAndNext(session, organization,
852 companyId, orderByComparator, false);
853
854 return array;
855 }
856 catch (Exception e) {
857 throw processException(e);
858 }
859 finally {
860 closeSession(session);
861 }
862 }
863
864 protected Organization getByLocations_PrevAndNext(Session session,
865 Organization organization, long companyId,
866 OrderByComparator orderByComparator, boolean previous) {
867 StringBundler query = null;
868
869 if (orderByComparator != null) {
870 query = new StringBundler(6 +
871 (orderByComparator.getOrderByFields().length * 6));
872 }
873 else {
874 query = new StringBundler(3);
875 }
876
877 query.append(_SQL_SELECT_ORGANIZATION_WHERE);
878
879 query.append(_FINDER_COLUMN_LOCATIONS_COMPANYID_2);
880
881 if (orderByComparator != null) {
882 String[] orderByFields = orderByComparator.getOrderByFields();
883
884 if (orderByFields.length > 0) {
885 query.append(WHERE_AND);
886 }
887
888 for (int i = 0; i < orderByFields.length; i++) {
889 query.append(_ORDER_BY_ENTITY_ALIAS);
890 query.append(orderByFields[i]);
891
892 if ((i + 1) < orderByFields.length) {
893 if (orderByComparator.isAscending() ^ previous) {
894 query.append(WHERE_GREATER_THAN_HAS_NEXT);
895 }
896 else {
897 query.append(WHERE_LESSER_THAN_HAS_NEXT);
898 }
899 }
900 else {
901 if (orderByComparator.isAscending() ^ previous) {
902 query.append(WHERE_GREATER_THAN);
903 }
904 else {
905 query.append(WHERE_LESSER_THAN);
906 }
907 }
908 }
909
910 query.append(ORDER_BY_CLAUSE);
911
912 for (int i = 0; i < orderByFields.length; i++) {
913 query.append(_ORDER_BY_ENTITY_ALIAS);
914 query.append(orderByFields[i]);
915
916 if ((i + 1) < orderByFields.length) {
917 if (orderByComparator.isAscending() ^ previous) {
918 query.append(ORDER_BY_ASC_HAS_NEXT);
919 }
920 else {
921 query.append(ORDER_BY_DESC_HAS_NEXT);
922 }
923 }
924 else {
925 if (orderByComparator.isAscending() ^ previous) {
926 query.append(ORDER_BY_ASC);
927 }
928 else {
929 query.append(ORDER_BY_DESC);
930 }
931 }
932 }
933 }
934
935 else {
936 query.append(OrganizationModelImpl.ORDER_BY_JPQL);
937 }
938
939 String sql = query.toString();
940
941 Query q = session.createQuery(sql);
942
943 q.setFirstResult(0);
944 q.setMaxResults(2);
945
946 QueryPos qPos = QueryPos.getInstance(q);
947
948 qPos.add(companyId);
949
950 if (orderByComparator != null) {
951 Object[] values = orderByComparator.getOrderByValues(organization);
952
953 for (Object value : values) {
954 qPos.add(value);
955 }
956 }
957
958 List<Organization> list = q.list();
959
960 if (list.size() == 2) {
961 return list.get(1);
962 }
963 else {
964 return null;
965 }
966 }
967
968 public List<Organization> findByC_P(long companyId,
969 long parentOrganizationId) throws SystemException {
970 return findByC_P(companyId, parentOrganizationId, QueryUtil.ALL_POS,
971 QueryUtil.ALL_POS, null);
972 }
973
974 public List<Organization> findByC_P(long companyId,
975 long parentOrganizationId, int start, int end)
976 throws SystemException {
977 return findByC_P(companyId, parentOrganizationId, start, end, null);
978 }
979
980 public List<Organization> findByC_P(long companyId,
981 long parentOrganizationId, int start, int end,
982 OrderByComparator orderByComparator) throws SystemException {
983 Object[] finderArgs = new Object[] {
984 companyId, parentOrganizationId,
985
986 String.valueOf(start), String.valueOf(end),
987 String.valueOf(orderByComparator)
988 };
989
990 List<Organization> list = (List<Organization>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_C_P,
991 finderArgs, this);
992
993 if (list == null) {
994 StringBundler query = null;
995
996 if (orderByComparator != null) {
997 query = new StringBundler(4 +
998 (orderByComparator.getOrderByFields().length * 3));
999 }
1000 else {
1001 query = new StringBundler(4);
1002 }
1003
1004 query.append(_SQL_SELECT_ORGANIZATION_WHERE);
1005
1006 query.append(_FINDER_COLUMN_C_P_COMPANYID_2);
1007
1008 query.append(_FINDER_COLUMN_C_P_PARENTORGANIZATIONID_2);
1009
1010 if (orderByComparator != null) {
1011 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1012 orderByComparator);
1013 }
1014
1015 else {
1016 query.append(OrganizationModelImpl.ORDER_BY_JPQL);
1017 }
1018
1019 String sql = query.toString();
1020
1021 Session session = null;
1022
1023 try {
1024 session = openSession();
1025
1026 Query q = session.createQuery(sql);
1027
1028 QueryPos qPos = QueryPos.getInstance(q);
1029
1030 qPos.add(companyId);
1031
1032 qPos.add(parentOrganizationId);
1033
1034 list = (List<Organization>)QueryUtil.list(q, getDialect(),
1035 start, end);
1036 }
1037 catch (Exception e) {
1038 throw processException(e);
1039 }
1040 finally {
1041 if (list == null) {
1042 list = new ArrayList<Organization>();
1043 }
1044
1045 cacheResult(list);
1046
1047 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_C_P, finderArgs,
1048 list);
1049
1050 closeSession(session);
1051 }
1052 }
1053
1054 return list;
1055 }
1056
1057 public Organization findByC_P_First(long companyId,
1058 long parentOrganizationId, OrderByComparator orderByComparator)
1059 throws NoSuchOrganizationException, SystemException {
1060 List<Organization> list = findByC_P(companyId, parentOrganizationId, 0,
1061 1, orderByComparator);
1062
1063 if (list.isEmpty()) {
1064 StringBundler msg = new StringBundler(6);
1065
1066 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1067
1068 msg.append("companyId=");
1069 msg.append(companyId);
1070
1071 msg.append(", parentOrganizationId=");
1072 msg.append(parentOrganizationId);
1073
1074 msg.append(StringPool.CLOSE_CURLY_BRACE);
1075
1076 throw new NoSuchOrganizationException(msg.toString());
1077 }
1078 else {
1079 return list.get(0);
1080 }
1081 }
1082
1083 public Organization findByC_P_Last(long companyId,
1084 long parentOrganizationId, OrderByComparator orderByComparator)
1085 throws NoSuchOrganizationException, SystemException {
1086 int count = countByC_P(companyId, parentOrganizationId);
1087
1088 List<Organization> list = findByC_P(companyId, parentOrganizationId,
1089 count - 1, count, orderByComparator);
1090
1091 if (list.isEmpty()) {
1092 StringBundler msg = new StringBundler(6);
1093
1094 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1095
1096 msg.append("companyId=");
1097 msg.append(companyId);
1098
1099 msg.append(", parentOrganizationId=");
1100 msg.append(parentOrganizationId);
1101
1102 msg.append(StringPool.CLOSE_CURLY_BRACE);
1103
1104 throw new NoSuchOrganizationException(msg.toString());
1105 }
1106 else {
1107 return list.get(0);
1108 }
1109 }
1110
1111 public Organization[] findByC_P_PrevAndNext(long organizationId,
1112 long companyId, long parentOrganizationId,
1113 OrderByComparator orderByComparator)
1114 throws NoSuchOrganizationException, SystemException {
1115 Organization organization = findByPrimaryKey(organizationId);
1116
1117 Session session = null;
1118
1119 try {
1120 session = openSession();
1121
1122 Organization[] array = new OrganizationImpl[3];
1123
1124 array[0] = getByC_P_PrevAndNext(session, organization, companyId,
1125 parentOrganizationId, orderByComparator, true);
1126
1127 array[1] = organization;
1128
1129 array[2] = getByC_P_PrevAndNext(session, organization, companyId,
1130 parentOrganizationId, orderByComparator, false);
1131
1132 return array;
1133 }
1134 catch (Exception e) {
1135 throw processException(e);
1136 }
1137 finally {
1138 closeSession(session);
1139 }
1140 }
1141
1142 protected Organization getByC_P_PrevAndNext(Session session,
1143 Organization organization, long companyId, long parentOrganizationId,
1144 OrderByComparator orderByComparator, boolean previous) {
1145 StringBundler query = null;
1146
1147 if (orderByComparator != null) {
1148 query = new StringBundler(6 +
1149 (orderByComparator.getOrderByFields().length * 6));
1150 }
1151 else {
1152 query = new StringBundler(3);
1153 }
1154
1155 query.append(_SQL_SELECT_ORGANIZATION_WHERE);
1156
1157 query.append(_FINDER_COLUMN_C_P_COMPANYID_2);
1158
1159 query.append(_FINDER_COLUMN_C_P_PARENTORGANIZATIONID_2);
1160
1161 if (orderByComparator != null) {
1162 String[] orderByFields = orderByComparator.getOrderByFields();
1163
1164 if (orderByFields.length > 0) {
1165 query.append(WHERE_AND);
1166 }
1167
1168 for (int i = 0; i < orderByFields.length; i++) {
1169 query.append(_ORDER_BY_ENTITY_ALIAS);
1170 query.append(orderByFields[i]);
1171
1172 if ((i + 1) < orderByFields.length) {
1173 if (orderByComparator.isAscending() ^ previous) {
1174 query.append(WHERE_GREATER_THAN_HAS_NEXT);
1175 }
1176 else {
1177 query.append(WHERE_LESSER_THAN_HAS_NEXT);
1178 }
1179 }
1180 else {
1181 if (orderByComparator.isAscending() ^ previous) {
1182 query.append(WHERE_GREATER_THAN);
1183 }
1184 else {
1185 query.append(WHERE_LESSER_THAN);
1186 }
1187 }
1188 }
1189
1190 query.append(ORDER_BY_CLAUSE);
1191
1192 for (int i = 0; i < orderByFields.length; i++) {
1193 query.append(_ORDER_BY_ENTITY_ALIAS);
1194 query.append(orderByFields[i]);
1195
1196 if ((i + 1) < orderByFields.length) {
1197 if (orderByComparator.isAscending() ^ previous) {
1198 query.append(ORDER_BY_ASC_HAS_NEXT);
1199 }
1200 else {
1201 query.append(ORDER_BY_DESC_HAS_NEXT);
1202 }
1203 }
1204 else {
1205 if (orderByComparator.isAscending() ^ previous) {
1206 query.append(ORDER_BY_ASC);
1207 }
1208 else {
1209 query.append(ORDER_BY_DESC);
1210 }
1211 }
1212 }
1213 }
1214
1215 else {
1216 query.append(OrganizationModelImpl.ORDER_BY_JPQL);
1217 }
1218
1219 String sql = query.toString();
1220
1221 Query q = session.createQuery(sql);
1222
1223 q.setFirstResult(0);
1224 q.setMaxResults(2);
1225
1226 QueryPos qPos = QueryPos.getInstance(q);
1227
1228 qPos.add(companyId);
1229
1230 qPos.add(parentOrganizationId);
1231
1232 if (orderByComparator != null) {
1233 Object[] values = orderByComparator.getOrderByValues(organization);
1234
1235 for (Object value : values) {
1236 qPos.add(value);
1237 }
1238 }
1239
1240 List<Organization> list = q.list();
1241
1242 if (list.size() == 2) {
1243 return list.get(1);
1244 }
1245 else {
1246 return null;
1247 }
1248 }
1249
1250 public Organization findByC_N(long companyId, String name)
1251 throws NoSuchOrganizationException, SystemException {
1252 Organization organization = fetchByC_N(companyId, name);
1253
1254 if (organization == null) {
1255 StringBundler msg = new StringBundler(6);
1256
1257 msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1258
1259 msg.append("companyId=");
1260 msg.append(companyId);
1261
1262 msg.append(", name=");
1263 msg.append(name);
1264
1265 msg.append(StringPool.CLOSE_CURLY_BRACE);
1266
1267 if (_log.isWarnEnabled()) {
1268 _log.warn(msg.toString());
1269 }
1270
1271 throw new NoSuchOrganizationException(msg.toString());
1272 }
1273
1274 return organization;
1275 }
1276
1277 public Organization fetchByC_N(long companyId, String name)
1278 throws SystemException {
1279 return fetchByC_N(companyId, name, true);
1280 }
1281
1282 public Organization fetchByC_N(long companyId, String name,
1283 boolean retrieveFromCache) throws SystemException {
1284 Object[] finderArgs = new Object[] { companyId, name };
1285
1286 Object result = null;
1287
1288 if (retrieveFromCache) {
1289 result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_C_N,
1290 finderArgs, this);
1291 }
1292
1293 if (result == null) {
1294 StringBundler query = new StringBundler(4);
1295
1296 query.append(_SQL_SELECT_ORGANIZATION_WHERE);
1297
1298 query.append(_FINDER_COLUMN_C_N_COMPANYID_2);
1299
1300 if (name == null) {
1301 query.append(_FINDER_COLUMN_C_N_NAME_1);
1302 }
1303 else {
1304 if (name.equals(StringPool.BLANK)) {
1305 query.append(_FINDER_COLUMN_C_N_NAME_3);
1306 }
1307 else {
1308 query.append(_FINDER_COLUMN_C_N_NAME_2);
1309 }
1310 }
1311
1312 query.append(OrganizationModelImpl.ORDER_BY_JPQL);
1313
1314 String sql = query.toString();
1315
1316 Session session = null;
1317
1318 try {
1319 session = openSession();
1320
1321 Query q = session.createQuery(sql);
1322
1323 QueryPos qPos = QueryPos.getInstance(q);
1324
1325 qPos.add(companyId);
1326
1327 if (name != null) {
1328 qPos.add(name);
1329 }
1330
1331 List<Organization> list = q.list();
1332
1333 result = list;
1334
1335 Organization organization = null;
1336
1337 if (list.isEmpty()) {
1338 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_N,
1339 finderArgs, list);
1340 }
1341 else {
1342 organization = list.get(0);
1343
1344 cacheResult(organization);
1345
1346 if ((organization.getCompanyId() != companyId) ||
1347 (organization.getName() == null) ||
1348 !organization.getName().equals(name)) {
1349 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_N,
1350 finderArgs, organization);
1351 }
1352 }
1353
1354 return organization;
1355 }
1356 catch (Exception e) {
1357 throw processException(e);
1358 }
1359 finally {
1360 if (result == null) {
1361 FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_N,
1362 finderArgs, new ArrayList<Organization>());
1363 }
1364
1365 closeSession(session);
1366 }
1367 }
1368 else {
1369 if (result instanceof List<?>) {
1370 return null;
1371 }
1372 else {
1373 return (Organization)result;
1374 }
1375 }
1376 }
1377
1378 public List<Organization> findAll() throws SystemException {
1379 return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1380 }
1381
1382 public List<Organization> findAll(int start, int end)
1383 throws SystemException {
1384 return findAll(start, end, null);
1385 }
1386
1387 public List<Organization> findAll(int start, int end,
1388 OrderByComparator orderByComparator) throws SystemException {
1389 Object[] finderArgs = new Object[] {
1390 String.valueOf(start), String.valueOf(end),
1391 String.valueOf(orderByComparator)
1392 };
1393
1394 List<Organization> list = (List<Organization>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
1395 finderArgs, this);
1396
1397 if (list == null) {
1398 StringBundler query = null;
1399 String sql = null;
1400
1401 if (orderByComparator != null) {
1402 query = new StringBundler(2 +
1403 (orderByComparator.getOrderByFields().length * 3));
1404
1405 query.append(_SQL_SELECT_ORGANIZATION);
1406
1407 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1408 orderByComparator);
1409
1410 sql = query.toString();
1411 }
1412 else {
1413 sql = _SQL_SELECT_ORGANIZATION.concat(OrganizationModelImpl.ORDER_BY_JPQL);
1414 }
1415
1416 Session session = null;
1417
1418 try {
1419 session = openSession();
1420
1421 Query q = session.createQuery(sql);
1422
1423 if (orderByComparator == null) {
1424 list = (List<Organization>)QueryUtil.list(q, getDialect(),
1425 start, end, false);
1426
1427 Collections.sort(list);
1428 }
1429 else {
1430 list = (List<Organization>)QueryUtil.list(q, getDialect(),
1431 start, end);
1432 }
1433 }
1434 catch (Exception e) {
1435 throw processException(e);
1436 }
1437 finally {
1438 if (list == null) {
1439 list = new ArrayList<Organization>();
1440 }
1441
1442 cacheResult(list);
1443
1444 FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
1445
1446 closeSession(session);
1447 }
1448 }
1449
1450 return list;
1451 }
1452
1453 public void removeByCompanyId(long companyId) throws SystemException {
1454 for (Organization organization : findByCompanyId(companyId)) {
1455 remove(organization);
1456 }
1457 }
1458
1459 public void removeByLocations(long companyId) throws SystemException {
1460 for (Organization organization : findByLocations(companyId)) {
1461 remove(organization);
1462 }
1463 }
1464
1465 public void removeByC_P(long companyId, long parentOrganizationId)
1466 throws SystemException {
1467 for (Organization organization : findByC_P(companyId,
1468 parentOrganizationId)) {
1469 remove(organization);
1470 }
1471 }
1472
1473 public void removeByC_N(long companyId, String name)
1474 throws NoSuchOrganizationException, SystemException {
1475 Organization organization = findByC_N(companyId, name);
1476
1477 remove(organization);
1478 }
1479
1480 public void removeAll() throws SystemException {
1481 for (Organization organization : findAll()) {
1482 remove(organization);
1483 }
1484 }
1485
1486 public int countByCompanyId(long companyId) throws SystemException {
1487 Object[] finderArgs = new Object[] { companyId };
1488
1489 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_COMPANYID,
1490 finderArgs, this);
1491
1492 if (count == null) {
1493 StringBundler query = new StringBundler(2);
1494
1495 query.append(_SQL_COUNT_ORGANIZATION_WHERE);
1496
1497 query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
1498
1499 String sql = query.toString();
1500
1501 Session session = null;
1502
1503 try {
1504 session = openSession();
1505
1506 Query q = session.createQuery(sql);
1507
1508 QueryPos qPos = QueryPos.getInstance(q);
1509
1510 qPos.add(companyId);
1511
1512 count = (Long)q.uniqueResult();
1513 }
1514 catch (Exception e) {
1515 throw processException(e);
1516 }
1517 finally {
1518 if (count == null) {
1519 count = Long.valueOf(0);
1520 }
1521
1522 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_COMPANYID,
1523 finderArgs, count);
1524
1525 closeSession(session);
1526 }
1527 }
1528
1529 return count.intValue();
1530 }
1531
1532 public int countByLocations(long companyId) throws SystemException {
1533 Object[] finderArgs = new Object[] { companyId };
1534
1535 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_LOCATIONS,
1536 finderArgs, this);
1537
1538 if (count == null) {
1539 StringBundler query = new StringBundler(2);
1540
1541 query.append(_SQL_COUNT_ORGANIZATION_WHERE);
1542
1543 query.append(_FINDER_COLUMN_LOCATIONS_COMPANYID_2);
1544
1545 String sql = query.toString();
1546
1547 Session session = null;
1548
1549 try {
1550 session = openSession();
1551
1552 Query q = session.createQuery(sql);
1553
1554 QueryPos qPos = QueryPos.getInstance(q);
1555
1556 qPos.add(companyId);
1557
1558 count = (Long)q.uniqueResult();
1559 }
1560 catch (Exception e) {
1561 throw processException(e);
1562 }
1563 finally {
1564 if (count == null) {
1565 count = Long.valueOf(0);
1566 }
1567
1568 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_LOCATIONS,
1569 finderArgs, count);
1570
1571 closeSession(session);
1572 }
1573 }
1574
1575 return count.intValue();
1576 }
1577
1578 public int countByC_P(long companyId, long parentOrganizationId)
1579 throws SystemException {
1580 Object[] finderArgs = new Object[] { companyId, parentOrganizationId };
1581
1582 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_P,
1583 finderArgs, this);
1584
1585 if (count == null) {
1586 StringBundler query = new StringBundler(3);
1587
1588 query.append(_SQL_COUNT_ORGANIZATION_WHERE);
1589
1590 query.append(_FINDER_COLUMN_C_P_COMPANYID_2);
1591
1592 query.append(_FINDER_COLUMN_C_P_PARENTORGANIZATIONID_2);
1593
1594 String sql = query.toString();
1595
1596 Session session = null;
1597
1598 try {
1599 session = openSession();
1600
1601 Query q = session.createQuery(sql);
1602
1603 QueryPos qPos = QueryPos.getInstance(q);
1604
1605 qPos.add(companyId);
1606
1607 qPos.add(parentOrganizationId);
1608
1609 count = (Long)q.uniqueResult();
1610 }
1611 catch (Exception e) {
1612 throw processException(e);
1613 }
1614 finally {
1615 if (count == null) {
1616 count = Long.valueOf(0);
1617 }
1618
1619 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_P, finderArgs,
1620 count);
1621
1622 closeSession(session);
1623 }
1624 }
1625
1626 return count.intValue();
1627 }
1628
1629 public int countByC_N(long companyId, String name)
1630 throws SystemException {
1631 Object[] finderArgs = new Object[] { companyId, name };
1632
1633 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_N,
1634 finderArgs, this);
1635
1636 if (count == null) {
1637 StringBundler query = new StringBundler(3);
1638
1639 query.append(_SQL_COUNT_ORGANIZATION_WHERE);
1640
1641 query.append(_FINDER_COLUMN_C_N_COMPANYID_2);
1642
1643 if (name == null) {
1644 query.append(_FINDER_COLUMN_C_N_NAME_1);
1645 }
1646 else {
1647 if (name.equals(StringPool.BLANK)) {
1648 query.append(_FINDER_COLUMN_C_N_NAME_3);
1649 }
1650 else {
1651 query.append(_FINDER_COLUMN_C_N_NAME_2);
1652 }
1653 }
1654
1655 String sql = query.toString();
1656
1657 Session session = null;
1658
1659 try {
1660 session = openSession();
1661
1662 Query q = session.createQuery(sql);
1663
1664 QueryPos qPos = QueryPos.getInstance(q);
1665
1666 qPos.add(companyId);
1667
1668 if (name != null) {
1669 qPos.add(name);
1670 }
1671
1672 count = (Long)q.uniqueResult();
1673 }
1674 catch (Exception e) {
1675 throw processException(e);
1676 }
1677 finally {
1678 if (count == null) {
1679 count = Long.valueOf(0);
1680 }
1681
1682 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_N, finderArgs,
1683 count);
1684
1685 closeSession(session);
1686 }
1687 }
1688
1689 return count.intValue();
1690 }
1691
1692 public int countAll() throws SystemException {
1693 Object[] finderArgs = new Object[0];
1694
1695 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
1696 finderArgs, this);
1697
1698 if (count == null) {
1699 Session session = null;
1700
1701 try {
1702 session = openSession();
1703
1704 Query q = session.createQuery(_SQL_COUNT_ORGANIZATION);
1705
1706 count = (Long)q.uniqueResult();
1707 }
1708 catch (Exception e) {
1709 throw processException(e);
1710 }
1711 finally {
1712 if (count == null) {
1713 count = Long.valueOf(0);
1714 }
1715
1716 FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
1717 count);
1718
1719 closeSession(session);
1720 }
1721 }
1722
1723 return count.intValue();
1724 }
1725
1726 public List<com.liferay.portal.model.Group> getGroups(long pk)
1727 throws SystemException {
1728 return getGroups(pk, QueryUtil.ALL_POS, QueryUtil.ALL_POS);
1729 }
1730
1731 public List<com.liferay.portal.model.Group> getGroups(long pk, int start,
1732 int end) throws SystemException {
1733 return getGroups(pk, start, end, null);
1734 }
1735
1736 public static final FinderPath FINDER_PATH_GET_GROUPS = new FinderPath(com.liferay.portal.model.impl.GroupModelImpl.ENTITY_CACHE_ENABLED,
1737 OrganizationModelImpl.FINDER_CACHE_ENABLED_GROUPS_ORGS,
1738 OrganizationModelImpl.MAPPING_TABLE_GROUPS_ORGS_NAME, "getGroups",
1739 new String[] {
1740 Long.class.getName(), "java.lang.Integer", "java.lang.Integer",
1741 "com.liferay.portal.kernel.util.OrderByComparator"
1742 });
1743
1744 public List<com.liferay.portal.model.Group> getGroups(long pk, int start,
1745 int end, OrderByComparator orderByComparator) throws SystemException {
1746 Object[] finderArgs = new Object[] {
1747 pk, String.valueOf(start), String.valueOf(end),
1748 String.valueOf(orderByComparator)
1749 };
1750
1751 List<com.liferay.portal.model.Group> list = (List<com.liferay.portal.model.Group>)FinderCacheUtil.getResult(FINDER_PATH_GET_GROUPS,
1752 finderArgs, this);
1753
1754 if (list == null) {
1755 Session session = null;
1756
1757 try {
1758 session = openSession();
1759
1760 String sql = null;
1761
1762 if (orderByComparator != null) {
1763 sql = _SQL_GETGROUPS.concat(ORDER_BY_CLAUSE)
1764 .concat(orderByComparator.getOrderBy());
1765 }
1766 else {
1767 sql = _SQL_GETGROUPS.concat(com.liferay.portal.model.impl.GroupModelImpl.ORDER_BY_SQL);
1768 }
1769
1770 SQLQuery q = session.createSQLQuery(sql);
1771
1772 q.addEntity("Group_",
1773 com.liferay.portal.model.impl.GroupImpl.class);
1774
1775 QueryPos qPos = QueryPos.getInstance(q);
1776
1777 qPos.add(pk);
1778
1779 list = (List<com.liferay.portal.model.Group>)QueryUtil.list(q,
1780 getDialect(), start, end);
1781 }
1782 catch (Exception e) {
1783 throw processException(e);
1784 }
1785 finally {
1786 if (list == null) {
1787 list = new ArrayList<com.liferay.portal.model.Group>();
1788 }
1789
1790 groupPersistence.cacheResult(list);
1791
1792 FinderCacheUtil.putResult(FINDER_PATH_GET_GROUPS, finderArgs,
1793 list);
1794
1795 closeSession(session);
1796 }
1797 }
1798
1799 return list;
1800 }
1801
1802 public static final FinderPath FINDER_PATH_GET_GROUPS_SIZE = new FinderPath(com.liferay.portal.model.impl.GroupModelImpl.ENTITY_CACHE_ENABLED,
1803 OrganizationModelImpl.FINDER_CACHE_ENABLED_GROUPS_ORGS,
1804 OrganizationModelImpl.MAPPING_TABLE_GROUPS_ORGS_NAME,
1805 "getGroupsSize", new String[] { Long.class.getName() });
1806
1807 public int getGroupsSize(long pk) throws SystemException {
1808 Object[] finderArgs = new Object[] { pk };
1809
1810 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_GET_GROUPS_SIZE,
1811 finderArgs, this);
1812
1813 if (count == null) {
1814 Session session = null;
1815
1816 try {
1817 session = openSession();
1818
1819 SQLQuery q = session.createSQLQuery(_SQL_GETGROUPSSIZE);
1820
1821 q.addScalar(COUNT_COLUMN_NAME,
1822 com.liferay.portal.kernel.dao.orm.Type.LONG);
1823
1824 QueryPos qPos = QueryPos.getInstance(q);
1825
1826 qPos.add(pk);
1827
1828 count = (Long)q.uniqueResult();
1829 }
1830 catch (Exception e) {
1831 throw processException(e);
1832 }
1833 finally {
1834 if (count == null) {
1835 count = Long.valueOf(0);
1836 }
1837
1838 FinderCacheUtil.putResult(FINDER_PATH_GET_GROUPS_SIZE,
1839 finderArgs, count);
1840
1841 closeSession(session);
1842 }
1843 }
1844
1845 return count.intValue();
1846 }
1847
1848 public static final FinderPath FINDER_PATH_CONTAINS_GROUP = new FinderPath(com.liferay.portal.model.impl.GroupModelImpl.ENTITY_CACHE_ENABLED,
1849 OrganizationModelImpl.FINDER_CACHE_ENABLED_GROUPS_ORGS,
1850 OrganizationModelImpl.MAPPING_TABLE_GROUPS_ORGS_NAME,
1851 "containsGroup",
1852 new String[] { Long.class.getName(), Long.class.getName() });
1853
1854 public boolean containsGroup(long pk, long groupPK)
1855 throws SystemException {
1856 Object[] finderArgs = new Object[] { pk, groupPK };
1857
1858 Boolean value = (Boolean)FinderCacheUtil.getResult(FINDER_PATH_CONTAINS_GROUP,
1859 finderArgs, this);
1860
1861 if (value == null) {
1862 try {
1863 value = Boolean.valueOf(containsGroup.contains(pk, groupPK));
1864 }
1865 catch (Exception e) {
1866 throw processException(e);
1867 }
1868 finally {
1869 if (value == null) {
1870 value = Boolean.FALSE;
1871 }
1872
1873 FinderCacheUtil.putResult(FINDER_PATH_CONTAINS_GROUP,
1874 finderArgs, value);
1875 }
1876 }
1877
1878 return value.booleanValue();
1879 }
1880
1881 public boolean containsGroups(long pk) throws SystemException {
1882 if (getGroupsSize(pk) > 0) {
1883 return true;
1884 }
1885 else {
1886 return false;
1887 }
1888 }
1889
1890 public void addGroup(long pk, long groupPK) throws SystemException {
1891 try {
1892 addGroup.add(pk, groupPK);
1893 }
1894 catch (Exception e) {
1895 throw processException(e);
1896 }
1897 finally {
1898 FinderCacheUtil.clearCache(OrganizationModelImpl.MAPPING_TABLE_GROUPS_ORGS_NAME);
1899 }
1900 }
1901
1902 public void addGroup(long pk, com.liferay.portal.model.Group group)
1903 throws SystemException {
1904 try {
1905 addGroup.add(pk, group.getPrimaryKey());
1906 }
1907 catch (Exception e) {
1908 throw processException(e);
1909 }
1910 finally {
1911 FinderCacheUtil.clearCache(OrganizationModelImpl.MAPPING_TABLE_GROUPS_ORGS_NAME);
1912 }
1913 }
1914
1915 public void addGroups(long pk, long[] groupPKs) throws SystemException {
1916 try {
1917 for (long groupPK : groupPKs) {
1918 addGroup.add(pk, groupPK);
1919 }
1920 }
1921 catch (Exception e) {
1922 throw processException(e);
1923 }
1924 finally {
1925 FinderCacheUtil.clearCache(OrganizationModelImpl.MAPPING_TABLE_GROUPS_ORGS_NAME);
1926 }
1927 }
1928
1929 public void addGroups(long pk, List<com.liferay.portal.model.Group> groups)
1930 throws SystemException {
1931 try {
1932 for (com.liferay.portal.model.Group group : groups) {
1933 addGroup.add(pk, group.getPrimaryKey());
1934 }
1935 }
1936 catch (Exception e) {
1937 throw processException(e);
1938 }
1939 finally {
1940 FinderCacheUtil.clearCache(OrganizationModelImpl.MAPPING_TABLE_GROUPS_ORGS_NAME);
1941 }
1942 }
1943
1944 public void clearGroups(long pk) throws SystemException {
1945 try {
1946 clearGroups.clear(pk);
1947 }
1948 catch (Exception e) {
1949 throw processException(e);
1950 }
1951 finally {
1952 FinderCacheUtil.clearCache(OrganizationModelImpl.MAPPING_TABLE_GROUPS_ORGS_NAME);
1953 }
1954 }
1955
1956 public void removeGroup(long pk, long groupPK) throws SystemException {
1957 try {
1958 removeGroup.remove(pk, groupPK);
1959 }
1960 catch (Exception e) {
1961 throw processException(e);
1962 }
1963 finally {
1964 FinderCacheUtil.clearCache(OrganizationModelImpl.MAPPING_TABLE_GROUPS_ORGS_NAME);
1965 }
1966 }
1967
1968 public void removeGroup(long pk, com.liferay.portal.model.Group group)
1969 throws SystemException {
1970 try {
1971 removeGroup.remove(pk, group.getPrimaryKey());
1972 }
1973 catch (Exception e) {
1974 throw processException(e);
1975 }
1976 finally {
1977 FinderCacheUtil.clearCache(OrganizationModelImpl.MAPPING_TABLE_GROUPS_ORGS_NAME);
1978 }
1979 }
1980
1981 public void removeGroups(long pk, long[] groupPKs)
1982 throws SystemException {
1983 try {
1984 for (long groupPK : groupPKs) {
1985 removeGroup.remove(pk, groupPK);
1986 }
1987 }
1988 catch (Exception e) {
1989 throw processException(e);
1990 }
1991 finally {
1992 FinderCacheUtil.clearCache(OrganizationModelImpl.MAPPING_TABLE_GROUPS_ORGS_NAME);
1993 }
1994 }
1995
1996 public void removeGroups(long pk,
1997 List<com.liferay.portal.model.Group> groups) throws SystemException {
1998 try {
1999 for (com.liferay.portal.model.Group group : groups) {
2000 removeGroup.remove(pk, group.getPrimaryKey());
2001 }
2002 }
2003 catch (Exception e) {
2004 throw processException(e);
2005 }
2006 finally {
2007 FinderCacheUtil.clearCache(OrganizationModelImpl.MAPPING_TABLE_GROUPS_ORGS_NAME);
2008 }
2009 }
2010
2011 public void setGroups(long pk, long[] groupPKs) throws SystemException {
2012 try {
2013 Set<Long> groupPKSet = SetUtil.fromArray(groupPKs);
2014
2015 List<com.liferay.portal.model.Group> groups = getGroups(pk);
2016
2017 for (com.liferay.portal.model.Group group : groups) {
2018 if (!groupPKSet.remove(group.getPrimaryKey())) {
2019 removeGroup.remove(pk, group.getPrimaryKey());
2020 }
2021 }
2022
2023 for (Long groupPK : groupPKSet) {
2024 addGroup.add(pk, groupPK);
2025 }
2026 }
2027 catch (Exception e) {
2028 throw processException(e);
2029 }
2030 finally {
2031 FinderCacheUtil.clearCache(OrganizationModelImpl.MAPPING_TABLE_GROUPS_ORGS_NAME);
2032 }
2033 }
2034
2035 public void setGroups(long pk, List<com.liferay.portal.model.Group> groups)
2036 throws SystemException {
2037 try {
2038 long[] groupPKs = new long[groups.size()];
2039
2040 for (int i = 0; i < groups.size(); i++) {
2041 com.liferay.portal.model.Group group = groups.get(i);
2042
2043 groupPKs[i] = group.getPrimaryKey();
2044 }
2045
2046 setGroups(pk, groupPKs);
2047 }
2048 catch (Exception e) {
2049 throw processException(e);
2050 }
2051 finally {
2052 FinderCacheUtil.clearCache(OrganizationModelImpl.MAPPING_TABLE_GROUPS_ORGS_NAME);
2053 }
2054 }
2055
2056 public List<com.liferay.portal.model.User> getUsers(long pk)
2057 throws SystemException {
2058 return getUsers(pk, QueryUtil.ALL_POS, QueryUtil.ALL_POS);
2059 }
2060
2061 public List<com.liferay.portal.model.User> getUsers(long pk, int start,
2062 int end) throws SystemException {
2063 return getUsers(pk, start, end, null);
2064 }
2065
2066 public static final FinderPath FINDER_PATH_GET_USERS = new FinderPath(com.liferay.portal.model.impl.UserModelImpl.ENTITY_CACHE_ENABLED,
2067 OrganizationModelImpl.FINDER_CACHE_ENABLED_USERS_ORGS,
2068 OrganizationModelImpl.MAPPING_TABLE_USERS_ORGS_NAME, "getUsers",
2069 new String[] {
2070 Long.class.getName(), "java.lang.Integer", "java.lang.Integer",
2071 "com.liferay.portal.kernel.util.OrderByComparator"
2072 });
2073
2074 public List<com.liferay.portal.model.User> getUsers(long pk, int start,
2075 int end, OrderByComparator orderByComparator) throws SystemException {
2076 Object[] finderArgs = new Object[] {
2077 pk, String.valueOf(start), String.valueOf(end),
2078 String.valueOf(orderByComparator)
2079 };
2080
2081 List<com.liferay.portal.model.User> list = (List<com.liferay.portal.model.User>)FinderCacheUtil.getResult(FINDER_PATH_GET_USERS,
2082 finderArgs, this);
2083
2084 if (list == null) {
2085 Session session = null;
2086
2087 try {
2088 session = openSession();
2089
2090 String sql = null;
2091
2092 if (orderByComparator != null) {
2093 sql = _SQL_GETUSERS.concat(ORDER_BY_CLAUSE)
2094 .concat(orderByComparator.getOrderBy());
2095 }
2096 else {
2097 sql = _SQL_GETUSERS;
2098 }
2099
2100 SQLQuery q = session.createSQLQuery(sql);
2101
2102 q.addEntity("User_",
2103 com.liferay.portal.model.impl.UserImpl.class);
2104
2105 QueryPos qPos = QueryPos.getInstance(q);
2106
2107 qPos.add(pk);
2108
2109 list = (List<com.liferay.portal.model.User>)QueryUtil.list(q,
2110 getDialect(), start, end);
2111 }
2112 catch (Exception e) {
2113 throw processException(e);
2114 }
2115 finally {
2116 if (list == null) {
2117 list = new ArrayList<com.liferay.portal.model.User>();
2118 }
2119
2120 userPersistence.cacheResult(list);
2121
2122 FinderCacheUtil.putResult(FINDER_PATH_GET_USERS, finderArgs,
2123 list);
2124
2125 closeSession(session);
2126 }
2127 }
2128
2129 return list;
2130 }
2131
2132 public static final FinderPath FINDER_PATH_GET_USERS_SIZE = new FinderPath(com.liferay.portal.model.impl.UserModelImpl.ENTITY_CACHE_ENABLED,
2133 OrganizationModelImpl.FINDER_CACHE_ENABLED_USERS_ORGS,
2134 OrganizationModelImpl.MAPPING_TABLE_USERS_ORGS_NAME,
2135 "getUsersSize", new String[] { Long.class.getName() });
2136
2137 public int getUsersSize(long pk) throws SystemException {
2138 Object[] finderArgs = new Object[] { pk };
2139
2140 Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_GET_USERS_SIZE,
2141 finderArgs, this);
2142
2143 if (count == null) {
2144 Session session = null;
2145
2146 try {
2147 session = openSession();
2148
2149 SQLQuery q = session.createSQLQuery(_SQL_GETUSERSSIZE);
2150
2151 q.addScalar(COUNT_COLUMN_NAME,
2152 com.liferay.portal.kernel.dao.orm.Type.LONG);
2153
2154 QueryPos qPos = QueryPos.getInstance(q);
2155
2156 qPos.add(pk);
2157
2158 count = (Long)q.uniqueResult();
2159 }
2160 catch (Exception e) {
2161 throw processException(e);
2162 }
2163 finally {
2164 if (count == null) {
2165 count = Long.valueOf(0);
2166 }
2167
2168 FinderCacheUtil.putResult(FINDER_PATH_GET_USERS_SIZE,
2169 finderArgs, count);
2170
2171 closeSession(session);
2172 }
2173 }
2174
2175 return count.intValue();
2176 }
2177
2178 public static final FinderPath FINDER_PATH_CONTAINS_USER = new FinderPath(com.liferay.portal.model.impl.UserModelImpl.ENTITY_CACHE_ENABLED,
2179 OrganizationModelImpl.FINDER_CACHE_ENABLED_USERS_ORGS,
2180 OrganizationModelImpl.MAPPING_TABLE_USERS_ORGS_NAME,
2181 "containsUser",
2182 new String[] { Long.class.getName(), Long.class.getName() });
2183
2184 public boolean containsUser(long pk, long userPK) throws SystemException {
2185 Object[] finderArgs = new Object[] { pk, userPK };
2186
2187 Boolean value = (Boolean)FinderCacheUtil.getResult(FINDER_PATH_CONTAINS_USER,
2188 finderArgs, this);
2189
2190 if (value == null) {
2191 try {
2192 value = Boolean.valueOf(containsUser.contains(pk, userPK));
2193 }
2194 catch (Exception e) {
2195 throw processException(e);
2196 }
2197 finally {
2198 if (value == null) {
2199 value = Boolean.FALSE;
2200 }
2201
2202 FinderCacheUtil.putResult(FINDER_PATH_CONTAINS_USER,
2203 finderArgs, value);
2204 }
2205 }
2206
2207 return value.booleanValue();
2208 }
2209
2210 public boolean containsUsers(long pk) throws SystemException {
2211 if (getUsersSize(pk) > 0) {
2212 return true;
2213 }
2214 else {
2215 return false;
2216 }
2217 }
2218
2219 public void addUser(long pk, long userPK) throws SystemException {
2220 try {
2221 addUser.add(pk, userPK);
2222 }
2223 catch (Exception e) {
2224 throw processException(e);
2225 }
2226 finally {
2227 FinderCacheUtil.clearCache(OrganizationModelImpl.MAPPING_TABLE_USERS_ORGS_NAME);
2228 }
2229 }
2230
2231 public void addUser(long pk, com.liferay.portal.model.User user)
2232 throws SystemException {
2233 try {
2234 addUser.add(pk, user.getPrimaryKey());
2235 }
2236 catch (Exception e) {
2237 throw processException(e);
2238 }
2239 finally {
2240 FinderCacheUtil.clearCache(OrganizationModelImpl.MAPPING_TABLE_USERS_ORGS_NAME);
2241 }
2242 }
2243
2244 public void addUsers(long pk, long[] userPKs) throws SystemException {
2245 try {
2246 for (long userPK : userPKs) {
2247 addUser.add(pk, userPK);
2248 }
2249 }
2250 catch (Exception e) {
2251 throw processException(e);
2252 }
2253 finally {
2254 FinderCacheUtil.clearCache(OrganizationModelImpl.MAPPING_TABLE_USERS_ORGS_NAME);
2255 }
2256 }
2257
2258 public void addUsers(long pk, List<com.liferay.portal.model.User> users)
2259 throws SystemException {
2260 try {
2261 for (com.liferay.portal.model.User user : users) {
2262 addUser.add(pk, user.getPrimaryKey());
2263 }
2264 }
2265 catch (Exception e) {
2266 throw processException(e);
2267 }
2268 finally {
2269 FinderCacheUtil.clearCache(OrganizationModelImpl.MAPPING_TABLE_USERS_ORGS_NAME);
2270 }
2271 }
2272
2273 public void clearUsers(long pk) throws SystemException {
2274 try {
2275 clearUsers.clear(pk);
2276 }
2277 catch (Exception e) {
2278 throw processException(e);
2279 }
2280 finally {
2281 FinderCacheUtil.clearCache(OrganizationModelImpl.MAPPING_TABLE_USERS_ORGS_NAME);
2282 }
2283 }
2284
2285 public void removeUser(long pk, long userPK) throws SystemException {
2286 try {
2287 removeUser.remove(pk, userPK);
2288 }
2289 catch (Exception e) {
2290 throw processException(e);
2291 }
2292 finally {
2293 FinderCacheUtil.clearCache(OrganizationModelImpl.MAPPING_TABLE_USERS_ORGS_NAME);
2294 }
2295 }
2296
2297 public void removeUser(long pk, com.liferay.portal.model.User user)
2298 throws SystemException {
2299 try {
2300 removeUser.remove(pk, user.getPrimaryKey());
2301 }
2302 catch (Exception e) {
2303 throw processException(e);
2304 }
2305 finally {
2306 FinderCacheUtil.clearCache(OrganizationModelImpl.MAPPING_TABLE_USERS_ORGS_NAME);
2307 }
2308 }
2309
2310 public void removeUsers(long pk, long[] userPKs) throws SystemException {
2311 try {
2312 for (long userPK : userPKs) {
2313 removeUser.remove(pk, userPK);
2314 }
2315 }
2316 catch (Exception e) {
2317 throw processException(e);
2318 }
2319 finally {
2320 FinderCacheUtil.clearCache(OrganizationModelImpl.MAPPING_TABLE_USERS_ORGS_NAME);
2321 }
2322 }
2323
2324 public void removeUsers(long pk, List<com.liferay.portal.model.User> users)
2325 throws SystemException {
2326 try {
2327 for (com.liferay.portal.model.User user : users) {
2328 removeUser.remove(pk, user.getPrimaryKey());
2329 }
2330 }
2331 catch (Exception e) {
2332 throw processException(e);
2333 }
2334 finally {
2335 FinderCacheUtil.clearCache(OrganizationModelImpl.MAPPING_TABLE_USERS_ORGS_NAME);
2336 }
2337 }
2338
2339 public void setUsers(long pk, long[] userPKs) throws SystemException {
2340 try {
2341 Set<Long> userPKSet = SetUtil.fromArray(userPKs);
2342
2343 List<com.liferay.portal.model.User> users = getUsers(pk);
2344
2345 for (com.liferay.portal.model.User user : users) {
2346 if (!userPKSet.remove(user.getPrimaryKey())) {
2347 removeUser.remove(pk, user.getPrimaryKey());
2348 }
2349 }
2350
2351 for (Long userPK : userPKSet) {
2352 addUser.add(pk, userPK);
2353 }
2354 }
2355 catch (Exception e) {
2356 throw processException(e);
2357 }
2358 finally {
2359 FinderCacheUtil.clearCache(OrganizationModelImpl.MAPPING_TABLE_USERS_ORGS_NAME);
2360 }
2361 }
2362
2363 public void setUsers(long pk, List<com.liferay.portal.model.User> users)
2364 throws SystemException {
2365 try {
2366 long[] userPKs = new long[users.size()];
2367
2368 for (int i = 0; i < users.size(); i++) {
2369 com.liferay.portal.model.User user = users.get(i);
2370
2371 userPKs[i] = user.getPrimaryKey();
2372 }
2373
2374 setUsers(pk, userPKs);
2375 }
2376 catch (Exception e) {
2377 throw processException(e);
2378 }
2379 finally {
2380 FinderCacheUtil.clearCache(OrganizationModelImpl.MAPPING_TABLE_USERS_ORGS_NAME);
2381 }
2382 }
2383
2384 public void rebuildTree(long companyId, boolean force)
2385 throws SystemException {
2386 if (force || (countOrphanTreeNodes(companyId) > 0)) {
2387 rebuildTree(companyId, 0, 1);
2388
2389 CacheRegistry.clear(OrganizationImpl.class.getName());
2390 EntityCacheUtil.clearCache(OrganizationImpl.class.getName());
2391 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
2392 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
2393 }
2394 }
2395
2396 protected long countOrphanTreeNodes(long companyId)
2397 throws SystemException {
2398 Session session = null;
2399
2400 try {
2401 session = openSession();
2402
2403 SQLQuery q = session.createSQLQuery(
2404 "SELECT COUNT(*) AS COUNT_VALUE FROM Organization_ WHERE companyId = ? AND (leftOrganizationId = 0 OR leftOrganizationId IS NULL OR rightOrganizationId = 0 OR rightOrganizationId IS NULL)");
2405
2406 q.addScalar(COUNT_COLUMN_NAME,
2407 com.liferay.portal.kernel.dao.orm.Type.LONG);
2408
2409 QueryPos qPos = QueryPos.getInstance(q);
2410
2411 qPos.add(companyId);
2412
2413 return (Long)q.uniqueResult();
2414 }
2415 catch (Exception e) {
2416 throw processException(e);
2417 }
2418 finally {
2419 closeSession(session);
2420 }
2421 }
2422
2423 protected void expandTree(Organization organization)
2424 throws SystemException {
2425 long companyId = organization.getCompanyId();
2426
2427 long lastRightOrganizationId = getLastRightOrganizationId(companyId,
2428 organization.getParentOrganizationId());
2429
2430 long leftOrganizationId = 2;
2431 long rightOrganizationId = 3;
2432
2433 if (lastRightOrganizationId > 0) {
2434 leftOrganizationId = lastRightOrganizationId + 1;
2435 rightOrganizationId = lastRightOrganizationId + 2;
2436
2437 expandTreeLeftOrganizationId.expand(companyId,
2438 lastRightOrganizationId);
2439 expandTreeRightOrganizationId.expand(companyId,
2440 lastRightOrganizationId);
2441
2442 CacheRegistry.clear(OrganizationImpl.class.getName());
2443 EntityCacheUtil.clearCache(OrganizationImpl.class.getName());
2444 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
2445 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
2446 }
2447
2448 organization.setLeftOrganizationId(leftOrganizationId);
2449 organization.setRightOrganizationId(rightOrganizationId);
2450 }
2451
2452 protected long getLastRightOrganizationId(long companyId,
2453 long parentOrganizationId) throws SystemException {
2454 Session session = null;
2455
2456 try {
2457 session = openSession();
2458
2459 SQLQuery q = session.createSQLQuery(
2460 "SELECT rightOrganizationId FROM Organization_ WHERE (companyId = ?) AND (parentOrganizationId = ?) ORDER BY rightOrganizationId DESC");
2461
2462 q.addScalar("rightOrganizationId",
2463 com.liferay.portal.kernel.dao.orm.Type.LONG);
2464
2465 QueryPos qPos = QueryPos.getInstance(q);
2466
2467 qPos.add(companyId);
2468 qPos.add(parentOrganizationId);
2469
2470 List<Long> list = (List<Long>)QueryUtil.list(q, getDialect(), 0, 1);
2471
2472 if (list.isEmpty()) {
2473 if (parentOrganizationId > 0) {
2474 Organization parentOrganization = findByPrimaryKey(parentOrganizationId);
2475
2476 return parentOrganization.getLeftOrganizationId();
2477 }
2478
2479 return 0;
2480 }
2481 else {
2482 return list.get(0);
2483 }
2484 }
2485 catch (Exception e) {
2486 throw processException(e);
2487 }
2488 finally {
2489 closeSession(session);
2490 }
2491 }
2492
2493 protected long rebuildTree(long companyId, long parentOrganizationId,
2494 long leftOrganizationId) throws SystemException {
2495 List<Long> organizationIds = null;
2496
2497 Session session = null;
2498
2499 try {
2500 session = openSession();
2501
2502 SQLQuery q = session.createSQLQuery(
2503 "SELECT organizationId FROM Organization_ WHERE companyId = ? AND parentOrganizationId = ? ORDER BY organizationId ASC");
2504
2505 q.addScalar("organizationId",
2506 com.liferay.portal.kernel.dao.orm.Type.LONG);
2507
2508 QueryPos qPos = QueryPos.getInstance(q);
2509
2510 qPos.add(companyId);
2511 qPos.add(parentOrganizationId);
2512
2513 organizationIds = q.list();
2514 }
2515 catch (Exception e) {
2516 throw processException(e);
2517 }
2518 finally {
2519 closeSession(session);
2520 }
2521
2522 long rightOrganizationId = leftOrganizationId + 1;
2523
2524 for (long organizationId : organizationIds) {
2525 rightOrganizationId = rebuildTree(companyId, organizationId,
2526 rightOrganizationId);
2527 }
2528
2529 if (parentOrganizationId > 0) {
2530 updateTree.update(parentOrganizationId, leftOrganizationId,
2531 rightOrganizationId);
2532 }
2533
2534 return rightOrganizationId + 1;
2535 }
2536
2537 protected void shrinkTree(Organization organization) {
2538 long companyId = organization.getCompanyId();
2539
2540 long leftOrganizationId = organization.getLeftOrganizationId();
2541 long rightOrganizationId = organization.getRightOrganizationId();
2542
2543 long delta = (rightOrganizationId - leftOrganizationId) + 1;
2544
2545 shrinkTreeLeftOrganizationId.shrink(companyId, rightOrganizationId,
2546 delta);
2547 shrinkTreeRightOrganizationId.shrink(companyId, rightOrganizationId,
2548 delta);
2549
2550 CacheRegistry.clear(OrganizationImpl.class.getName());
2551 EntityCacheUtil.clearCache(OrganizationImpl.class.getName());
2552 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
2553 FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
2554 }
2555
2556 public void afterPropertiesSet() {
2557 String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
2558 com.liferay.portal.util.PropsUtil.get(
2559 "value.object.listener.com.liferay.portal.model.Organization")));
2560
2561 if (listenerClassNames.length > 0) {
2562 try {
2563 List<ModelListener<Organization>> listenersList = new ArrayList<ModelListener<Organization>>();
2564
2565 for (String listenerClassName : listenerClassNames) {
2566 listenersList.add((ModelListener<Organization>)InstanceFactory.newInstance(
2567 listenerClassName));
2568 }
2569
2570 listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
2571 }
2572 catch (Exception e) {
2573 _log.error(e);
2574 }
2575 }
2576
2577 containsGroup = new ContainsGroup(this);
2578
2579 addGroup = new AddGroup(this);
2580 clearGroups = new ClearGroups(this);
2581 removeGroup = new RemoveGroup(this);
2582
2583 containsUser = new ContainsUser(this);
2584
2585 addUser = new AddUser(this);
2586 clearUsers = new ClearUsers(this);
2587 removeUser = new RemoveUser(this);
2588
2589 expandTreeLeftOrganizationId = new ExpandTreeLeftOrganizationId();
2590 expandTreeRightOrganizationId = new ExpandTreeRightOrganizationId();
2591 shrinkTreeLeftOrganizationId = new ShrinkTreeLeftOrganizationId();
2592 shrinkTreeRightOrganizationId = new ShrinkTreeRightOrganizationId();
2593 updateTree = new UpdateTree();
2594 }
2595
2596 public void destroy() {
2597 EntityCacheUtil.removeCache(OrganizationImpl.class.getName());
2598 FinderCacheUtil.removeCache(FINDER_CLASS_NAME_ENTITY);
2599 FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST);
2600 }
2601
2602 @BeanReference(type = AccountPersistence.class)
2603 protected AccountPersistence accountPersistence;
2604 @BeanReference(type = AddressPersistence.class)
2605 protected AddressPersistence addressPersistence;
2606 @BeanReference(type = BrowserTrackerPersistence.class)
2607 protected BrowserTrackerPersistence browserTrackerPersistence;
2608 @BeanReference(type = ClassNamePersistence.class)
2609 protected ClassNamePersistence classNamePersistence;
2610 @BeanReference(type = CompanyPersistence.class)
2611 protected CompanyPersistence companyPersistence;
2612 @BeanReference(type = ContactPersistence.class)
2613 protected ContactPersistence contactPersistence;
2614 @BeanReference(type = CountryPersistence.class)
2615 protected CountryPersistence countryPersistence;
2616 @BeanReference(type = EmailAddressPersistence.class)
2617 protected EmailAddressPersistence emailAddressPersistence;
2618 @BeanReference(type = GroupPersistence.class)
2619 protected GroupPersistence groupPersistence;
2620 @BeanReference(type = ImagePersistence.class)
2621 protected ImagePersistence imagePersistence;
2622 @BeanReference(type = LayoutPersistence.class)
2623 protected LayoutPersistence layoutPersistence;
2624 @BeanReference(type = LayoutSetPersistence.class)
2625 protected LayoutSetPersistence layoutSetPersistence;
2626 @BeanReference(type = ListTypePersistence.class)
2627 protected ListTypePersistence listTypePersistence;
2628 @BeanReference(type = LockPersistence.class)
2629 protected LockPersistence lockPersistence;
2630 @BeanReference(type = MembershipRequestPersistence.class)
2631 protected MembershipRequestPersistence membershipRequestPersistence;
2632 @BeanReference(type = OrganizationPersistence.class)
2633 protected OrganizationPersistence organizationPersistence;
2634 @BeanReference(type = OrgGroupPermissionPersistence.class)
2635 protected OrgGroupPermissionPersistence orgGroupPermissionPersistence;
2636 @BeanReference(type = OrgGroupRolePersistence.class)
2637 protected OrgGroupRolePersistence orgGroupRolePersistence;
2638 @BeanReference(type = OrgLaborPersistence.class)
2639 protected OrgLaborPersistence orgLaborPersistence;
2640 @BeanReference(type = PasswordPolicyPersistence.class)
2641 protected PasswordPolicyPersistence passwordPolicyPersistence;
2642 @BeanReference(type = PasswordPolicyRelPersistence.class)
2643 protected PasswordPolicyRelPersistence passwordPolicyRelPersistence;
2644 @BeanReference(type = PasswordTrackerPersistence.class)
2645 protected PasswordTrackerPersistence passwordTrackerPersistence;
2646 @BeanReference(type = PermissionPersistence.class)
2647 protected PermissionPersistence permissionPersistence;
2648 @BeanReference(type = PhonePersistence.class)
2649 protected PhonePersistence phonePersistence;
2650 @BeanReference(type = PluginSettingPersistence.class)
2651 protected PluginSettingPersistence pluginSettingPersistence;
2652 @BeanReference(type = PortletPersistence.class)
2653 protected PortletPersistence portletPersistence;
2654 @BeanReference(type = PortletItemPersistence.class)
2655 protected PortletItemPersistence portletItemPersistence;
2656 @BeanReference(type = PortletPreferencesPersistence.class)
2657 protected PortletPreferencesPersistence portletPreferencesPersistence;
2658 @BeanReference(type = RegionPersistence.class)
2659 protected RegionPersistence regionPersistence;
2660 @BeanReference(type = ReleasePersistence.class)
2661 protected ReleasePersistence releasePersistence;
2662 @BeanReference(type = ResourcePersistence.class)
2663 protected ResourcePersistence resourcePersistence;
2664 @BeanReference(type = ResourceActionPersistence.class)
2665 protected ResourceActionPersistence resourceActionPersistence;
2666 @BeanReference(type = ResourceCodePersistence.class)
2667 protected ResourceCodePersistence resourceCodePersistence;
2668 @BeanReference(type = ResourcePermissionPersistence.class)
2669 protected ResourcePermissionPersistence resourcePermissionPersistence;
2670 @BeanReference(type = RolePersistence.class)
2671 protected RolePersistence rolePersistence;
2672 @BeanReference(type = ServiceComponentPersistence.class)
2673 protected ServiceComponentPersistence serviceComponentPersistence;
2674 @BeanReference(type = ShardPersistence.class)
2675 protected ShardPersistence shardPersistence;
2676 @BeanReference(type = SubscriptionPersistence.class)
2677 protected SubscriptionPersistence subscriptionPersistence;
2678 @BeanReference(type = UserPersistence.class)
2679 protected UserPersistence userPersistence;
2680 @BeanReference(type = UserGroupPersistence.class)
2681 protected UserGroupPersistence userGroupPersistence;
2682 @BeanReference(type = UserGroupGroupRolePersistence.class)
2683 protected UserGroupGroupRolePersistence userGroupGroupRolePersistence;
2684 @BeanReference(type = UserGroupRolePersistence.class)
2685 protected UserGroupRolePersistence userGroupRolePersistence;
2686 @BeanReference(type = UserIdMapperPersistence.class)
2687 protected UserIdMapperPersistence userIdMapperPersistence;
2688 @BeanReference(type = UserTrackerPersistence.class)
2689 protected UserTrackerPersistence userTrackerPersistence;
2690 @BeanReference(type = UserTrackerPathPersistence.class)
2691 protected UserTrackerPathPersistence userTrackerPathPersistence;
2692 @BeanReference(type = WebDAVPropsPersistence.class)
2693 protected WebDAVPropsPersistence webDAVPropsPersistence;
2694 @BeanReference(type = WebsitePersistence.class)
2695 protected WebsitePersistence websitePersistence;
2696 @BeanReference(type = ExpandoValuePersistence.class)
2697 protected ExpandoValuePersistence expandoValuePersistence;
2698 @BeanReference(type = TagsAssetPersistence.class)
2699 protected TagsAssetPersistence tagsAssetPersistence;
2700 protected ContainsGroup containsGroup;
2701 protected AddGroup addGroup;
2702 protected ClearGroups clearGroups;
2703 protected RemoveGroup removeGroup;
2704 protected ContainsUser containsUser;
2705 protected AddUser addUser;
2706 protected ClearUsers clearUsers;
2707 protected RemoveUser removeUser;
2708
2709 protected class ContainsGroup {
2710 protected ContainsGroup(OrganizationPersistenceImpl persistenceImpl) {
2711 super();
2712
2713 _mappingSqlQuery = MappingSqlQueryFactoryUtil.getMappingSqlQuery(getDataSource(),
2714 _SQL_CONTAINSGROUP,
2715 new int[] { java.sql.Types.BIGINT, java.sql.Types.BIGINT },
2716 RowMapper.COUNT);
2717 }
2718
2719 protected boolean contains(long organizationId, long groupId) {
2720 List<Integer> results = _mappingSqlQuery.execute(new Object[] {
2721 new Long(organizationId), new Long(groupId)
2722 });
2723
2724 if (results.size() > 0) {
2725 Integer count = results.get(0);
2726
2727 if (count.intValue() > 0) {
2728 return true;
2729 }
2730 }
2731
2732 return false;
2733 }
2734
2735 private MappingSqlQuery _mappingSqlQuery;
2736 }
2737
2738 protected class AddGroup {
2739 protected AddGroup(OrganizationPersistenceImpl persistenceImpl) {
2740 _sqlUpdate = SqlUpdateFactoryUtil.getSqlUpdate(getDataSource(),
2741 "INSERT INTO Groups_Orgs (organizationId, groupId) VALUES (?, ?)",
2742 new int[] { java.sql.Types.BIGINT, java.sql.Types.BIGINT });
2743 _persistenceImpl = persistenceImpl;
2744 }
2745
2746 protected void add(long organizationId, long groupId)
2747 throws SystemException {
2748 if (!_persistenceImpl.containsGroup.contains(organizationId, groupId)) {
2749 ModelListener<com.liferay.portal.model.Group>[] groupListeners = groupPersistence.getListeners();
2750
2751 for (ModelListener<Organization> listener : listeners) {
2752 listener.onBeforeAddAssociation(organizationId,
2753 com.liferay.portal.model.Group.class.getName(), groupId);
2754 }
2755
2756 for (ModelListener<com.liferay.portal.model.Group> listener : groupListeners) {
2757 listener.onBeforeAddAssociation(groupId,
2758 Organization.class.getName(), organizationId);
2759 }
2760
2761 _sqlUpdate.update(new Object[] {
2762 new Long(organizationId), new Long(groupId)
2763 });
2764
2765 for (ModelListener<Organization> listener : listeners) {
2766 listener.onAfterAddAssociation(organizationId,
2767 com.liferay.portal.model.Group.class.getName(), groupId);
2768 }
2769
2770 for (ModelListener<com.liferay.portal.model.Group> listener : groupListeners) {
2771 listener.onAfterAddAssociation(groupId,
2772 Organization.class.getName(), organizationId);
2773 }
2774 }
2775 }
2776
2777 private SqlUpdate _sqlUpdate;
2778 private OrganizationPersistenceImpl _persistenceImpl;
2779 }
2780
2781 protected class ClearGroups {
2782 protected ClearGroups(OrganizationPersistenceImpl persistenceImpl) {
2783 _sqlUpdate = SqlUpdateFactoryUtil.getSqlUpdate(getDataSource(),
2784 "DELETE FROM Groups_Orgs WHERE organizationId = ?",
2785 new int[] { java.sql.Types.BIGINT });
2786 }
2787
2788 protected void clear(long organizationId) throws SystemException {
2789 ModelListener<com.liferay.portal.model.Group>[] groupListeners = groupPersistence.getListeners();
2790
2791 List<com.liferay.portal.model.Group> groups = null;
2792
2793 if ((listeners.length > 0) || (groupListeners.length > 0)) {
2794 groups = getGroups(organizationId);
2795
2796 for (com.liferay.portal.model.Group group : groups) {
2797 for (ModelListener<Organization> listener : listeners) {
2798 listener.onBeforeRemoveAssociation(organizationId,
2799 com.liferay.portal.model.Group.class.getName(),
2800 group.getPrimaryKey());
2801 }
2802
2803 for (ModelListener<com.liferay.portal.model.Group> listener : groupListeners) {
2804 listener.onBeforeRemoveAssociation(group.getPrimaryKey(),
2805 Organization.class.getName(), organizationId);
2806 }
2807 }
2808 }
2809
2810 _sqlUpdate.update(new Object[] { new Long(organizationId) });
2811
2812 if ((listeners.length > 0) || (groupListeners.length > 0)) {
2813 for (com.liferay.portal.model.Group group : groups) {
2814 for (ModelListener<Organization> listener : listeners) {
2815 listener.onAfterRemoveAssociation(organizationId,
2816 com.liferay.portal.model.Group.class.getName(),
2817 group.getPrimaryKey());
2818 }
2819
2820 for (ModelListener<com.liferay.portal.model.Group> listener : groupListeners) {
2821 listener.onAfterRemoveAssociation(group.getPrimaryKey(),
2822 Organization.class.getName(), organizationId);
2823 }
2824 }
2825 }
2826 }
2827
2828 private SqlUpdate _sqlUpdate;
2829 }
2830
2831 protected class RemoveGroup {
2832 protected RemoveGroup(OrganizationPersistenceImpl persistenceImpl) {
2833 _sqlUpdate = SqlUpdateFactoryUtil.getSqlUpdate(getDataSource(),
2834 "DELETE FROM Groups_Orgs WHERE organizationId = ? AND groupId = ?",
2835 new int[] { java.sql.Types.BIGINT, java.sql.Types.BIGINT });
2836 _persistenceImpl = persistenceImpl;
2837 }
2838
2839 protected void remove(long organizationId, long groupId)
2840 throws SystemException {
2841 if (_persistenceImpl.containsGroup.contains(organizationId, groupId)) {
2842 ModelListener<com.liferay.portal.model.Group>[] groupListeners = groupPersistence.getListeners();
2843
2844 for (ModelListener<Organization> listener : listeners) {
2845 listener.onBeforeRemoveAssociation(organizationId,
2846 com.liferay.portal.model.Group.class.getName(), groupId);
2847 }
2848
2849 for (ModelListener<com.liferay.portal.model.Group> listener : groupListeners) {
2850 listener.onBeforeRemoveAssociation(groupId,
2851 Organization.class.getName(), organizationId);
2852 }
2853
2854 _sqlUpdate.update(new Object[] {
2855 new Long(organizationId), new Long(groupId)
2856 });
2857
2858 for (ModelListener<Organization> listener : listeners) {
2859 listener.onAfterRemoveAssociation(organizationId,
2860 com.liferay.portal.model.Group.class.getName(), groupId);
2861 }
2862
2863 for (ModelListener<com.liferay.portal.model.Group> listener : groupListeners) {
2864 listener.onAfterRemoveAssociation(groupId,
2865 Organization.class.getName(), organizationId);
2866 }
2867 }
2868 }
2869
2870 private SqlUpdate _sqlUpdate;
2871 private OrganizationPersistenceImpl _persistenceImpl;
2872 }
2873
2874 protected class ContainsUser {
2875 protected ContainsUser(OrganizationPersistenceImpl persistenceImpl) {
2876 super();
2877
2878 _mappingSqlQuery = MappingSqlQueryFactoryUtil.getMappingSqlQuery(getDataSource(),
2879 _SQL_CONTAINSUSER,
2880 new int[] { java.sql.Types.BIGINT, java.sql.Types.BIGINT },
2881 RowMapper.COUNT);
2882 }
2883
2884 protected boolean contains(long organizationId, long userId) {
2885 List<Integer> results = _mappingSqlQuery.execute(new Object[] {
2886 new Long(organizationId), new Long(userId)
2887 });
2888
2889 if (results.size() > 0) {
2890 Integer count = results.get(0);
2891
2892 if (count.intValue() > 0) {
2893 return true;
2894 }
2895 }
2896
2897 return false;
2898 }
2899
2900 private MappingSqlQuery _mappingSqlQuery;
2901 }
2902
2903 protected class AddUser {
2904 protected AddUser(OrganizationPersistenceImpl persistenceImpl) {
2905 _sqlUpdate = SqlUpdateFactoryUtil.getSqlUpdate(getDataSource(),
2906 "INSERT INTO Users_Orgs (organizationId, userId) VALUES (?, ?)",
2907 new int[] { java.sql.Types.BIGINT, java.sql.Types.BIGINT });
2908 _persistenceImpl = persistenceImpl;
2909 }
2910
2911 protected void add(long organizationId, long userId)
2912 throws SystemException {
2913 if (!_persistenceImpl.containsUser.contains(organizationId, userId)) {
2914 ModelListener<com.liferay.portal.model.User>[] userListeners = userPersistence.getListeners();
2915
2916 for (ModelListener<Organization> listener : listeners) {
2917 listener.onBeforeAddAssociation(organizationId,
2918 com.liferay.portal.model.User.class.getName(), userId);
2919 }
2920
2921 for (ModelListener<com.liferay.portal.model.User> listener : userListeners) {
2922 listener.onBeforeAddAssociation(userId,
2923 Organization.class.getName(), organizationId);
2924 }
2925
2926 _sqlUpdate.update(new Object[] {
2927 new Long(organizationId), new Long(userId)
2928 });
2929
2930 for (ModelListener<Organization> listener : listeners) {
2931 listener.onAfterAddAssociation(organizationId,
2932 com.liferay.portal.model.User.class.getName(), userId);
2933 }
2934
2935 for (ModelListener<com.liferay.portal.model.User> listener : userListeners) {
2936 listener.onAfterAddAssociation(userId,
2937 Organization.class.getName(), organizationId);
2938 }
2939 }
2940 }
2941
2942 private SqlUpdate _sqlUpdate;
2943 private OrganizationPersistenceImpl _persistenceImpl;
2944 }
2945
2946 protected class ClearUsers {
2947 protected ClearUsers(OrganizationPersistenceImpl persistenceImpl) {
2948 _sqlUpdate = SqlUpdateFactoryUtil.getSqlUpdate(getDataSource(),
2949 "DELETE FROM Users_Orgs WHERE organizationId = ?",
2950 new int[] { java.sql.Types.BIGINT });
2951 }
2952
2953 protected void clear(long organizationId) throws SystemException {
2954 ModelListener<com.liferay.portal.model.User>[] userListeners = userPersistence.getListeners();
2955
2956 List<com.liferay.portal.model.User> users = null;
2957
2958 if ((listeners.length > 0) || (userListeners.length > 0)) {
2959 users = getUsers(organizationId);
2960
2961 for (com.liferay.portal.model.User user : users) {
2962 for (ModelListener<Organization> listener : listeners) {
2963 listener.onBeforeRemoveAssociation(organizationId,
2964 com.liferay.portal.model.User.class.getName(),
2965 user.getPrimaryKey());
2966 }
2967
2968 for (ModelListener<com.liferay.portal.model.User> listener : userListeners) {
2969 listener.onBeforeRemoveAssociation(user.getPrimaryKey(),
2970 Organization.class.getName(), organizationId);
2971 }
2972 }
2973 }
2974
2975 _sqlUpdate.update(new Object[] { new Long(organizationId) });
2976
2977 if ((listeners.length > 0) || (userListeners.length > 0)) {
2978 for (com.liferay.portal.model.User user : users) {
2979 for (ModelListener<Organization> listener : listeners) {
2980 listener.onAfterRemoveAssociation(organizationId,
2981 com.liferay.portal.model.User.class.getName(),
2982 user.getPrimaryKey());
2983 }
2984
2985 for (ModelListener<com.liferay.portal.model.User> listener : userListeners) {
2986 listener.onAfterRemoveAssociation(user.getPrimaryKey(),
2987 Organization.class.getName(), organizationId);
2988 }
2989 }
2990 }
2991 }
2992
2993 private SqlUpdate _sqlUpdate;
2994 }
2995
2996 protected class RemoveUser {
2997 protected RemoveUser(OrganizationPersistenceImpl persistenceImpl) {
2998 _sqlUpdate = SqlUpdateFactoryUtil.getSqlUpdate(getDataSource(),
2999 "DELETE FROM Users_Orgs WHERE organizationId = ? AND userId = ?",
3000 new int[] { java.sql.Types.BIGINT, java.sql.Types.BIGINT });
3001 _persistenceImpl = persistenceImpl;
3002 }
3003
3004 protected void remove(long organizationId, long userId)
3005 throws SystemException {
3006 if (_persistenceImpl.containsUser.contains(organizationId, userId)) {
3007 ModelListener<com.liferay.portal.model.User>[] userListeners = userPersistence.getListeners();
3008
3009 for (ModelListener<Organization> listener : listeners) {
3010 listener.onBeforeRemoveAssociation(organizationId,
3011 com.liferay.portal.model.User.class.getName(), userId);
3012 }
3013
3014 for (ModelListener<com.liferay.portal.model.User> listener : userListeners) {
3015 listener.onBeforeRemoveAssociation(userId,
3016 Organization.class.getName(), organizationId);
3017 }
3018
3019 _sqlUpdate.update(new Object[] {
3020 new Long(organizationId), new Long(userId)
3021 });
3022
3023 for (ModelListener<Organization> listener : listeners) {
3024 listener.onAfterRemoveAssociation(organizationId,
3025 com.liferay.portal.model.User.class.getName(), userId);
3026 }
3027
3028 for (ModelListener<com.liferay.portal.model.User> listener : userListeners) {
3029 listener.onAfterRemoveAssociation(userId,
3030 Organization.class.getName(), organizationId);
3031 }
3032 }
3033 }
3034
3035 private SqlUpdate _sqlUpdate;
3036 private OrganizationPersistenceImpl _persistenceImpl;
3037 }
3038
3039 protected ExpandTreeLeftOrganizationId expandTreeLeftOrganizationId;
3040 protected ExpandTreeRightOrganizationId expandTreeRightOrganizationId;
3041 protected ShrinkTreeLeftOrganizationId shrinkTreeLeftOrganizationId;
3042 protected ShrinkTreeRightOrganizationId shrinkTreeRightOrganizationId;
3043 protected UpdateTree updateTree;
3044
3045 protected class ExpandTreeLeftOrganizationId {
3046 protected ExpandTreeLeftOrganizationId() {
3047 _sqlUpdate = SqlUpdateFactoryUtil.getSqlUpdate(getDataSource(),
3048 "UPDATE Organization_ SET leftOrganizationId = (leftOrganizationId + 2) WHERE (companyId = ?) AND (leftOrganizationId > ?)",
3049 new int[] { java.sql.Types.BIGINT, java.sql.Types.BIGINT });
3050 }
3051
3052 protected void expand(long companyId, long leftOrganizationId) {
3053 _sqlUpdate.update(new Object[] { companyId, leftOrganizationId });
3054 }
3055
3056 private SqlUpdate _sqlUpdate;
3057 }
3058
3059 protected class ExpandTreeRightOrganizationId {
3060 protected ExpandTreeRightOrganizationId() {
3061 _sqlUpdate = SqlUpdateFactoryUtil.getSqlUpdate(getDataSource(),
3062 "UPDATE Organization_ SET rightOrganizationId = (rightOrganizationId + 2) WHERE (companyId = ?) AND (rightOrganizationId > ?)",
3063 new int[] { java.sql.Types.BIGINT, java.sql.Types.BIGINT });
3064 }
3065
3066 protected void expand(long companyId, long rightOrganizationId) {
3067 _sqlUpdate.update(new Object[] { companyId, rightOrganizationId });
3068 }
3069
3070 private SqlUpdate _sqlUpdate;
3071 }
3072
3073 protected class ShrinkTreeLeftOrganizationId {
3074 protected ShrinkTreeLeftOrganizationId() {
3075 _sqlUpdate = SqlUpdateFactoryUtil.getSqlUpdate(getDataSource(),
3076 "UPDATE Organization_ SET leftOrganizationId = (leftOrganizationId - ?) WHERE (companyId = ?) AND (leftOrganizationId > ?)",
3077 new int[] {
3078 java.sql.Types.BIGINT, java.sql.Types.BIGINT,
3079 java.sql.Types.BIGINT
3080 });
3081 }
3082
3083 protected void shrink(long companyId, long leftOrganizationId,
3084 long delta) {
3085 _sqlUpdate.update(new Object[] { delta, companyId, leftOrganizationId });
3086 }
3087
3088 private SqlUpdate _sqlUpdate;
3089 }
3090
3091 protected class ShrinkTreeRightOrganizationId {
3092 protected ShrinkTreeRightOrganizationId() {
3093 _sqlUpdate = SqlUpdateFactoryUtil.getSqlUpdate(getDataSource(),
3094 "UPDATE Organization_ SET rightOrganizationId = (rightOrganizationId - ?) WHERE (companyId = ?) AND (rightOrganizationId > ?)",
3095 new int[] {
3096 java.sql.Types.BIGINT, java.sql.Types.BIGINT,
3097 java.sql.Types.BIGINT
3098 });
3099 }
3100
3101 protected void shrink(long companyId, long rightOrganizationId,
3102 long delta) {
3103 _sqlUpdate.update(new Object[] { delta, companyId, rightOrganizationId });
3104 }
3105
3106 private SqlUpdate _sqlUpdate;
3107 }
3108
3109 protected class UpdateTree {
3110 protected UpdateTree() {
3111 _sqlUpdate = SqlUpdateFactoryUtil.getSqlUpdate(getDataSource(),
3112 "UPDATE Organization_ SET leftOrganizationId = ?, rightOrganizationId = ? WHERE organizationId = ?",
3113 new int[] {
3114 java.sql.Types.BIGINT, java.sql.Types.BIGINT,
3115 java.sql.Types.BIGINT
3116 });
3117 }
3118
3119 protected void update(long organizationId, long leftOrganizationId,
3120 long rightOrganizationId) {
3121 _sqlUpdate.update(new Object[] {
3122 leftOrganizationId, rightOrganizationId, organizationId
3123 });
3124 }
3125
3126 private SqlUpdate _sqlUpdate;
3127 }
3128
3129 private static final String _SQL_SELECT_ORGANIZATION = "SELECT organization FROM Organization organization";
3130 private static final String _SQL_SELECT_ORGANIZATION_WHERE = "SELECT organization FROM Organization organization WHERE ";
3131 private static final String _SQL_COUNT_ORGANIZATION = "SELECT COUNT(organization) FROM Organization organization";
3132 private static final String _SQL_COUNT_ORGANIZATION_WHERE = "SELECT COUNT(organization) FROM Organization organization WHERE ";
3133 private static final String _SQL_GETGROUPS = "SELECT {Group_.*} FROM Group_ INNER JOIN Groups_Orgs ON (Groups_Orgs.groupId = Group_.groupId) WHERE (Groups_Orgs.organizationId = ?)";
3134 private static final String _SQL_GETGROUPSSIZE = "SELECT COUNT(*) AS COUNT_VALUE FROM Groups_Orgs WHERE organizationId = ?";
3135 private static final String _SQL_CONTAINSGROUP = "SELECT COUNT(*) AS COUNT_VALUE FROM Groups_Orgs WHERE organizationId = ? AND groupId = ?";
3136 private static final String _SQL_GETUSERS = "SELECT {User_.*} FROM User_ INNER JOIN Users_Orgs ON (Users_Orgs.userId = User_.userId) WHERE (Users_Orgs.organizationId = ?)";
3137 private static final String _SQL_GETUSERSSIZE = "SELECT COUNT(*) AS COUNT_VALUE FROM Users_Orgs WHERE organizationId = ?";
3138 private static final String _SQL_CONTAINSUSER = "SELECT COUNT(*) AS COUNT_VALUE FROM Users_Orgs WHERE organizationId = ? AND userId = ?";
3139 private static final String _FINDER_COLUMN_COMPANYID_COMPANYID_2 = "organization.companyId = ?";
3140 private static final String _FINDER_COLUMN_LOCATIONS_COMPANYID_2 = "organization.companyId = ? AND organization.parentOrganizationId != 0";
3141 private static final String _FINDER_COLUMN_C_P_COMPANYID_2 = "organization.companyId = ? AND ";
3142 private static final String _FINDER_COLUMN_C_P_PARENTORGANIZATIONID_2 = "organization.parentOrganizationId = ?";
3143 private static final String _FINDER_COLUMN_C_N_COMPANYID_2 = "organization.companyId = ? AND ";
3144 private static final String _FINDER_COLUMN_C_N_NAME_1 = "organization.name IS NULL";
3145 private static final String _FINDER_COLUMN_C_N_NAME_2 = "organization.name = ?";
3146 private static final String _FINDER_COLUMN_C_N_NAME_3 = "(organization.name IS NULL OR organization.name = ?)";
3147 private static final String _ORDER_BY_ENTITY_ALIAS = "organization.";
3148 private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No Organization exists with the primary key ";
3149 private static final String _NO_SUCH_ENTITY_WITH_KEY = "No Organization exists with the key {";
3150 private static Log _log = LogFactoryUtil.getLog(OrganizationPersistenceImpl.class);
3151}