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