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