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