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