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