1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * The contents of this file are subject to the terms of the Liferay Enterprise
5    * Subscription License ("License"). You may not use this file except in
6    * compliance with the License. You can obtain a copy of the License by
7    * contacting Liferay, Inc. See the License for the specific language governing
8    * permissions and limitations under the License, including but not limited to
9    * distribution rights of the Software.
10   *
11   *
12   *
13   */
14  
15  package com.liferay.portlet.imagegallery.service.persistence;
16  
17  import com.liferay.portal.NoSuchModelException;
18  import com.liferay.portal.SystemException;
19  import com.liferay.portal.kernel.annotation.BeanReference;
20  import com.liferay.portal.kernel.cache.CacheRegistry;
21  import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
22  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
23  import com.liferay.portal.kernel.dao.orm.FinderPath;
24  import com.liferay.portal.kernel.dao.orm.Query;
25  import com.liferay.portal.kernel.dao.orm.QueryPos;
26  import com.liferay.portal.kernel.dao.orm.QueryUtil;
27  import com.liferay.portal.kernel.dao.orm.Session;
28  import com.liferay.portal.kernel.log.Log;
29  import com.liferay.portal.kernel.log.LogFactoryUtil;
30  import com.liferay.portal.kernel.util.GetterUtil;
31  import com.liferay.portal.kernel.util.InstanceFactory;
32  import com.liferay.portal.kernel.util.OrderByComparator;
33  import com.liferay.portal.kernel.util.StringBundler;
34  import com.liferay.portal.kernel.util.StringPool;
35  import com.liferay.portal.kernel.util.StringUtil;
36  import com.liferay.portal.kernel.util.Validator;
37  import com.liferay.portal.kernel.uuid.PortalUUIDUtil;
38  import com.liferay.portal.model.ModelListener;
39  import com.liferay.portal.service.persistence.BatchSessionUtil;
40  import com.liferay.portal.service.persistence.GroupPersistence;
41  import com.liferay.portal.service.persistence.ImagePersistence;
42  import com.liferay.portal.service.persistence.LayoutPersistence;
43  import com.liferay.portal.service.persistence.ResourcePersistence;
44  import com.liferay.portal.service.persistence.UserPersistence;
45  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
46  
47  import com.liferay.portlet.expando.service.persistence.ExpandoValuePersistence;
48  import com.liferay.portlet.imagegallery.NoSuchFolderException;
49  import com.liferay.portlet.imagegallery.model.IGFolder;
50  import com.liferay.portlet.imagegallery.model.impl.IGFolderImpl;
51  import com.liferay.portlet.imagegallery.model.impl.IGFolderModelImpl;
52  
53  import java.io.Serializable;
54  
55  import java.util.ArrayList;
56  import java.util.Collections;
57  import java.util.List;
58  
59  /**
60   * <a href="IGFolderPersistenceImpl.java.html"><b><i>View Source</i></b></a>
61   *
62   * <p>
63   * ServiceBuilder generated this class. Modifications in this class will be
64   * overwritten the next time is generated.
65   * </p>
66   *
67   * @author    Brian Wing Shun Chan
68   * @see       IGFolderPersistence
69   * @see       IGFolderUtil
70   * @generated
71   */
72  public class IGFolderPersistenceImpl extends BasePersistenceImpl<IGFolder>
73      implements IGFolderPersistence {
74      public static final String FINDER_CLASS_NAME_ENTITY = IGFolderImpl.class.getName();
75      public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
76          ".List";
77      public static final FinderPath FINDER_PATH_FIND_BY_UUID = new FinderPath(IGFolderModelImpl.ENTITY_CACHE_ENABLED,
78              IGFolderModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
79              "findByUuid",
80              new String[] {
81                  String.class.getName(),
82                  
83              "java.lang.Integer", "java.lang.Integer",
84                  "com.liferay.portal.kernel.util.OrderByComparator"
85              });
86      public static final FinderPath FINDER_PATH_COUNT_BY_UUID = new FinderPath(IGFolderModelImpl.ENTITY_CACHE_ENABLED,
87              IGFolderModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
88              "countByUuid", new String[] { String.class.getName() });
89      public static final FinderPath FINDER_PATH_FETCH_BY_UUID_G = new FinderPath(IGFolderModelImpl.ENTITY_CACHE_ENABLED,
90              IGFolderModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_ENTITY,
91              "fetchByUUID_G",
92              new String[] { String.class.getName(), Long.class.getName() });
93      public static final FinderPath FINDER_PATH_COUNT_BY_UUID_G = new FinderPath(IGFolderModelImpl.ENTITY_CACHE_ENABLED,
94              IGFolderModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
95              "countByUUID_G",
96              new String[] { String.class.getName(), Long.class.getName() });
97      public static final FinderPath FINDER_PATH_FIND_BY_GROUPID = new FinderPath(IGFolderModelImpl.ENTITY_CACHE_ENABLED,
98              IGFolderModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
99              "findByGroupId",
100             new String[] {
101                 Long.class.getName(),
102                 
103             "java.lang.Integer", "java.lang.Integer",
104                 "com.liferay.portal.kernel.util.OrderByComparator"
105             });
106     public static final FinderPath FINDER_PATH_COUNT_BY_GROUPID = new FinderPath(IGFolderModelImpl.ENTITY_CACHE_ENABLED,
107             IGFolderModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
108             "countByGroupId", new String[] { Long.class.getName() });
109     public static final FinderPath FINDER_PATH_FIND_BY_COMPANYID = new FinderPath(IGFolderModelImpl.ENTITY_CACHE_ENABLED,
110             IGFolderModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
111             "findByCompanyId",
112             new String[] {
113                 Long.class.getName(),
114                 
115             "java.lang.Integer", "java.lang.Integer",
116                 "com.liferay.portal.kernel.util.OrderByComparator"
117             });
118     public static final FinderPath FINDER_PATH_COUNT_BY_COMPANYID = new FinderPath(IGFolderModelImpl.ENTITY_CACHE_ENABLED,
119             IGFolderModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
120             "countByCompanyId", new String[] { Long.class.getName() });
121     public static final FinderPath FINDER_PATH_FIND_BY_G_P = new FinderPath(IGFolderModelImpl.ENTITY_CACHE_ENABLED,
122             IGFolderModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
123             "findByG_P",
124             new String[] {
125                 Long.class.getName(), Long.class.getName(),
126                 
127             "java.lang.Integer", "java.lang.Integer",
128                 "com.liferay.portal.kernel.util.OrderByComparator"
129             });
130     public static final FinderPath FINDER_PATH_COUNT_BY_G_P = new FinderPath(IGFolderModelImpl.ENTITY_CACHE_ENABLED,
131             IGFolderModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
132             "countByG_P",
133             new String[] { Long.class.getName(), Long.class.getName() });
134     public static final FinderPath FINDER_PATH_FETCH_BY_G_P_N = new FinderPath(IGFolderModelImpl.ENTITY_CACHE_ENABLED,
135             IGFolderModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_ENTITY,
136             "fetchByG_P_N",
137             new String[] {
138                 Long.class.getName(), Long.class.getName(),
139                 String.class.getName()
140             });
141     public static final FinderPath FINDER_PATH_COUNT_BY_G_P_N = new FinderPath(IGFolderModelImpl.ENTITY_CACHE_ENABLED,
142             IGFolderModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
143             "countByG_P_N",
144             new String[] {
145                 Long.class.getName(), Long.class.getName(),
146                 String.class.getName()
147             });
148     public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(IGFolderModelImpl.ENTITY_CACHE_ENABLED,
149             IGFolderModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
150             "findAll", new String[0]);
151     public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(IGFolderModelImpl.ENTITY_CACHE_ENABLED,
152             IGFolderModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
153             "countAll", new String[0]);
154 
155     public void cacheResult(IGFolder igFolder) {
156         EntityCacheUtil.putResult(IGFolderModelImpl.ENTITY_CACHE_ENABLED,
157             IGFolderImpl.class, igFolder.getPrimaryKey(), igFolder);
158 
159         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
160             new Object[] { igFolder.getUuid(), new Long(igFolder.getGroupId()) },
161             igFolder);
162 
163         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_P_N,
164             new Object[] {
165                 new Long(igFolder.getGroupId()),
166                 new Long(igFolder.getParentFolderId()),
167                 
168             igFolder.getName()
169             }, igFolder);
170     }
171 
172     public void cacheResult(List<IGFolder> igFolders) {
173         for (IGFolder igFolder : igFolders) {
174             if (EntityCacheUtil.getResult(
175                         IGFolderModelImpl.ENTITY_CACHE_ENABLED,
176                         IGFolderImpl.class, igFolder.getPrimaryKey(), this) == null) {
177                 cacheResult(igFolder);
178             }
179         }
180     }
181 
182     public void clearCache() {
183         CacheRegistry.clear(IGFolderImpl.class.getName());
184         EntityCacheUtil.clearCache(IGFolderImpl.class.getName());
185         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
186         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
187     }
188 
189     public void clearCache(IGFolder igFolder) {
190         EntityCacheUtil.removeResult(IGFolderModelImpl.ENTITY_CACHE_ENABLED,
191             IGFolderImpl.class, igFolder.getPrimaryKey());
192 
193         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
194             new Object[] { igFolder.getUuid(), new Long(igFolder.getGroupId()) });
195 
196         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_P_N,
197             new Object[] {
198                 new Long(igFolder.getGroupId()),
199                 new Long(igFolder.getParentFolderId()),
200                 
201             igFolder.getName()
202             });
203     }
204 
205     public IGFolder create(long folderId) {
206         IGFolder igFolder = new IGFolderImpl();
207 
208         igFolder.setNew(true);
209         igFolder.setPrimaryKey(folderId);
210 
211         String uuid = PortalUUIDUtil.generate();
212 
213         igFolder.setUuid(uuid);
214 
215         return igFolder;
216     }
217 
218     public IGFolder remove(Serializable primaryKey)
219         throws NoSuchModelException, SystemException {
220         return remove(((Long)primaryKey).longValue());
221     }
222 
223     public IGFolder remove(long folderId)
224         throws NoSuchFolderException, SystemException {
225         Session session = null;
226 
227         try {
228             session = openSession();
229 
230             IGFolder igFolder = (IGFolder)session.get(IGFolderImpl.class,
231                     new Long(folderId));
232 
233             if (igFolder == null) {
234                 if (_log.isWarnEnabled()) {
235                     _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + folderId);
236                 }
237 
238                 throw new NoSuchFolderException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
239                     folderId);
240             }
241 
242             return remove(igFolder);
243         }
244         catch (NoSuchFolderException nsee) {
245             throw nsee;
246         }
247         catch (Exception e) {
248             throw processException(e);
249         }
250         finally {
251             closeSession(session);
252         }
253     }
254 
255     protected IGFolder removeImpl(IGFolder igFolder) throws SystemException {
256         igFolder = toUnwrappedModel(igFolder);
257 
258         Session session = null;
259 
260         try {
261             session = openSession();
262 
263             BatchSessionUtil.delete(session, igFolder);
264         }
265         catch (Exception e) {
266             throw processException(e);
267         }
268         finally {
269             closeSession(session);
270         }
271 
272         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
273 
274         IGFolderModelImpl igFolderModelImpl = (IGFolderModelImpl)igFolder;
275 
276         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
277             new Object[] {
278                 igFolderModelImpl.getOriginalUuid(),
279                 new Long(igFolderModelImpl.getOriginalGroupId())
280             });
281 
282         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_P_N,
283             new Object[] {
284                 new Long(igFolderModelImpl.getOriginalGroupId()),
285                 new Long(igFolderModelImpl.getOriginalParentFolderId()),
286                 
287             igFolderModelImpl.getOriginalName()
288             });
289 
290         EntityCacheUtil.removeResult(IGFolderModelImpl.ENTITY_CACHE_ENABLED,
291             IGFolderImpl.class, igFolder.getPrimaryKey());
292 
293         return igFolder;
294     }
295 
296     /**
297      * @deprecated Use {@link BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)}.
298      */
299     public IGFolder update(IGFolder igFolder) throws SystemException {
300         if (_log.isWarnEnabled()) {
301             _log.warn(
302                 "Using the deprecated update(IGFolder igFolder) method. Use update(IGFolder igFolder, boolean merge) instead.");
303         }
304 
305         return update(igFolder, false);
306     }
307 
308     public IGFolder updateImpl(
309         com.liferay.portlet.imagegallery.model.IGFolder igFolder, boolean merge)
310         throws SystemException {
311         igFolder = toUnwrappedModel(igFolder);
312 
313         boolean isNew = igFolder.isNew();
314 
315         IGFolderModelImpl igFolderModelImpl = (IGFolderModelImpl)igFolder;
316 
317         if (Validator.isNull(igFolder.getUuid())) {
318             String uuid = PortalUUIDUtil.generate();
319 
320             igFolder.setUuid(uuid);
321         }
322 
323         Session session = null;
324 
325         try {
326             session = openSession();
327 
328             BatchSessionUtil.update(session, igFolder, merge);
329 
330             igFolder.setNew(false);
331         }
332         catch (Exception e) {
333             throw processException(e);
334         }
335         finally {
336             closeSession(session);
337         }
338 
339         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
340 
341         EntityCacheUtil.putResult(IGFolderModelImpl.ENTITY_CACHE_ENABLED,
342             IGFolderImpl.class, igFolder.getPrimaryKey(), igFolder);
343 
344         if (!isNew &&
345                 (!Validator.equals(igFolder.getUuid(),
346                     igFolderModelImpl.getOriginalUuid()) ||
347                 (igFolder.getGroupId() != igFolderModelImpl.getOriginalGroupId()))) {
348             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
349                 new Object[] {
350                     igFolderModelImpl.getOriginalUuid(),
351                     new Long(igFolderModelImpl.getOriginalGroupId())
352                 });
353         }
354 
355         if (isNew ||
356                 (!Validator.equals(igFolder.getUuid(),
357                     igFolderModelImpl.getOriginalUuid()) ||
358                 (igFolder.getGroupId() != igFolderModelImpl.getOriginalGroupId()))) {
359             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
360                 new Object[] { igFolder.getUuid(), new Long(
361                         igFolder.getGroupId()) }, igFolder);
362         }
363 
364         if (!isNew &&
365                 ((igFolder.getGroupId() != igFolderModelImpl.getOriginalGroupId()) ||
366                 (igFolder.getParentFolderId() != igFolderModelImpl.getOriginalParentFolderId()) ||
367                 !Validator.equals(igFolder.getName(),
368                     igFolderModelImpl.getOriginalName()))) {
369             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_P_N,
370                 new Object[] {
371                     new Long(igFolderModelImpl.getOriginalGroupId()),
372                     new Long(igFolderModelImpl.getOriginalParentFolderId()),
373                     
374                 igFolderModelImpl.getOriginalName()
375                 });
376         }
377 
378         if (isNew ||
379                 ((igFolder.getGroupId() != igFolderModelImpl.getOriginalGroupId()) ||
380                 (igFolder.getParentFolderId() != igFolderModelImpl.getOriginalParentFolderId()) ||
381                 !Validator.equals(igFolder.getName(),
382                     igFolderModelImpl.getOriginalName()))) {
383             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_P_N,
384                 new Object[] {
385                     new Long(igFolder.getGroupId()),
386                     new Long(igFolder.getParentFolderId()),
387                     
388                 igFolder.getName()
389                 }, igFolder);
390         }
391 
392         return igFolder;
393     }
394 
395     protected IGFolder toUnwrappedModel(IGFolder igFolder) {
396         if (igFolder instanceof IGFolderImpl) {
397             return igFolder;
398         }
399 
400         IGFolderImpl igFolderImpl = new IGFolderImpl();
401 
402         igFolderImpl.setNew(igFolder.isNew());
403         igFolderImpl.setPrimaryKey(igFolder.getPrimaryKey());
404 
405         igFolderImpl.setUuid(igFolder.getUuid());
406         igFolderImpl.setFolderId(igFolder.getFolderId());
407         igFolderImpl.setGroupId(igFolder.getGroupId());
408         igFolderImpl.setCompanyId(igFolder.getCompanyId());
409         igFolderImpl.setUserId(igFolder.getUserId());
410         igFolderImpl.setCreateDate(igFolder.getCreateDate());
411         igFolderImpl.setModifiedDate(igFolder.getModifiedDate());
412         igFolderImpl.setParentFolderId(igFolder.getParentFolderId());
413         igFolderImpl.setName(igFolder.getName());
414         igFolderImpl.setDescription(igFolder.getDescription());
415 
416         return igFolderImpl;
417     }
418 
419     public IGFolder findByPrimaryKey(Serializable primaryKey)
420         throws NoSuchModelException, SystemException {
421         return findByPrimaryKey(((Long)primaryKey).longValue());
422     }
423 
424     public IGFolder findByPrimaryKey(long folderId)
425         throws NoSuchFolderException, SystemException {
426         IGFolder igFolder = fetchByPrimaryKey(folderId);
427 
428         if (igFolder == null) {
429             if (_log.isWarnEnabled()) {
430                 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + folderId);
431             }
432 
433             throw new NoSuchFolderException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
434                 folderId);
435         }
436 
437         return igFolder;
438     }
439 
440     public IGFolder fetchByPrimaryKey(Serializable primaryKey)
441         throws SystemException {
442         return fetchByPrimaryKey(((Long)primaryKey).longValue());
443     }
444 
445     public IGFolder fetchByPrimaryKey(long folderId) throws SystemException {
446         IGFolder igFolder = (IGFolder)EntityCacheUtil.getResult(IGFolderModelImpl.ENTITY_CACHE_ENABLED,
447                 IGFolderImpl.class, folderId, this);
448 
449         if (igFolder == null) {
450             Session session = null;
451 
452             try {
453                 session = openSession();
454 
455                 igFolder = (IGFolder)session.get(IGFolderImpl.class,
456                         new Long(folderId));
457             }
458             catch (Exception e) {
459                 throw processException(e);
460             }
461             finally {
462                 if (igFolder != null) {
463                     cacheResult(igFolder);
464                 }
465 
466                 closeSession(session);
467             }
468         }
469 
470         return igFolder;
471     }
472 
473     public List<IGFolder> findByUuid(String uuid) throws SystemException {
474         return findByUuid(uuid, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
475     }
476 
477     public List<IGFolder> findByUuid(String uuid, int start, int end)
478         throws SystemException {
479         return findByUuid(uuid, start, end, null);
480     }
481 
482     public List<IGFolder> findByUuid(String uuid, int start, int end,
483         OrderByComparator orderByComparator) throws SystemException {
484         Object[] finderArgs = new Object[] {
485                 uuid,
486                 
487                 String.valueOf(start), String.valueOf(end),
488                 String.valueOf(orderByComparator)
489             };
490 
491         List<IGFolder> list = (List<IGFolder>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_UUID,
492                 finderArgs, this);
493 
494         if (list == null) {
495             StringBundler query = null;
496 
497             if (orderByComparator != null) {
498                 query = new StringBundler(3 +
499                         (orderByComparator.getOrderByFields().length * 3));
500             }
501             else {
502                 query = new StringBundler(3);
503             }
504 
505             query.append(_SQL_SELECT_IGFOLDER_WHERE);
506 
507             if (uuid == null) {
508                 query.append(_FINDER_COLUMN_UUID_UUID_1);
509             }
510             else {
511                 if (uuid.equals(StringPool.BLANK)) {
512                     query.append(_FINDER_COLUMN_UUID_UUID_3);
513                 }
514                 else {
515                     query.append(_FINDER_COLUMN_UUID_UUID_2);
516                 }
517             }
518 
519             if (orderByComparator != null) {
520                 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
521                     orderByComparator);
522             }
523 
524             else {
525                 query.append(IGFolderModelImpl.ORDER_BY_JPQL);
526             }
527 
528             String sql = query.toString();
529 
530             Session session = null;
531 
532             try {
533                 session = openSession();
534 
535                 Query q = session.createQuery(sql);
536 
537                 QueryPos qPos = QueryPos.getInstance(q);
538 
539                 if (uuid != null) {
540                     qPos.add(uuid);
541                 }
542 
543                 list = (List<IGFolder>)QueryUtil.list(q, getDialect(), start,
544                         end);
545             }
546             catch (Exception e) {
547                 throw processException(e);
548             }
549             finally {
550                 if (list == null) {
551                     list = new ArrayList<IGFolder>();
552                 }
553 
554                 cacheResult(list);
555 
556                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_UUID, finderArgs,
557                     list);
558 
559                 closeSession(session);
560             }
561         }
562 
563         return list;
564     }
565 
566     public IGFolder findByUuid_First(String uuid,
567         OrderByComparator orderByComparator)
568         throws NoSuchFolderException, SystemException {
569         List<IGFolder> list = findByUuid(uuid, 0, 1, orderByComparator);
570 
571         if (list.isEmpty()) {
572             StringBundler msg = new StringBundler(4);
573 
574             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
575 
576             msg.append("uuid=");
577             msg.append(uuid);
578 
579             msg.append(StringPool.CLOSE_CURLY_BRACE);
580 
581             throw new NoSuchFolderException(msg.toString());
582         }
583         else {
584             return list.get(0);
585         }
586     }
587 
588     public IGFolder findByUuid_Last(String uuid,
589         OrderByComparator orderByComparator)
590         throws NoSuchFolderException, SystemException {
591         int count = countByUuid(uuid);
592 
593         List<IGFolder> list = findByUuid(uuid, count - 1, count,
594                 orderByComparator);
595 
596         if (list.isEmpty()) {
597             StringBundler msg = new StringBundler(4);
598 
599             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
600 
601             msg.append("uuid=");
602             msg.append(uuid);
603 
604             msg.append(StringPool.CLOSE_CURLY_BRACE);
605 
606             throw new NoSuchFolderException(msg.toString());
607         }
608         else {
609             return list.get(0);
610         }
611     }
612 
613     public IGFolder[] findByUuid_PrevAndNext(long folderId, String uuid,
614         OrderByComparator orderByComparator)
615         throws NoSuchFolderException, SystemException {
616         IGFolder igFolder = findByPrimaryKey(folderId);
617 
618         Session session = null;
619 
620         try {
621             session = openSession();
622 
623             IGFolder[] array = new IGFolderImpl[3];
624 
625             array[0] = getByUuid_PrevAndNext(session, igFolder, uuid,
626                     orderByComparator, true);
627 
628             array[1] = igFolder;
629 
630             array[2] = getByUuid_PrevAndNext(session, igFolder, uuid,
631                     orderByComparator, false);
632 
633             return array;
634         }
635         catch (Exception e) {
636             throw processException(e);
637         }
638         finally {
639             closeSession(session);
640         }
641     }
642 
643     protected IGFolder getByUuid_PrevAndNext(Session session,
644         IGFolder igFolder, String uuid, OrderByComparator orderByComparator,
645         boolean previous) {
646         StringBundler query = null;
647 
648         if (orderByComparator != null) {
649             query = new StringBundler(6 +
650                     (orderByComparator.getOrderByFields().length * 6));
651         }
652         else {
653             query = new StringBundler(3);
654         }
655 
656         query.append(_SQL_SELECT_IGFOLDER_WHERE);
657 
658         if (uuid == null) {
659             query.append(_FINDER_COLUMN_UUID_UUID_1);
660         }
661         else {
662             if (uuid.equals(StringPool.BLANK)) {
663                 query.append(_FINDER_COLUMN_UUID_UUID_3);
664             }
665             else {
666                 query.append(_FINDER_COLUMN_UUID_UUID_2);
667             }
668         }
669 
670         if (orderByComparator != null) {
671             String[] orderByFields = orderByComparator.getOrderByFields();
672 
673             if (orderByFields.length > 0) {
674                 query.append(WHERE_AND);
675             }
676 
677             for (int i = 0; i < orderByFields.length; i++) {
678                 query.append(_ORDER_BY_ENTITY_ALIAS);
679                 query.append(orderByFields[i]);
680 
681                 if ((i + 1) < orderByFields.length) {
682                     if (orderByComparator.isAscending() ^ previous) {
683                         query.append(WHERE_GREATER_THAN_HAS_NEXT);
684                     }
685                     else {
686                         query.append(WHERE_LESSER_THAN_HAS_NEXT);
687                     }
688                 }
689                 else {
690                     if (orderByComparator.isAscending() ^ previous) {
691                         query.append(WHERE_GREATER_THAN);
692                     }
693                     else {
694                         query.append(WHERE_LESSER_THAN);
695                     }
696                 }
697             }
698 
699             query.append(ORDER_BY_CLAUSE);
700 
701             for (int i = 0; i < orderByFields.length; i++) {
702                 query.append(_ORDER_BY_ENTITY_ALIAS);
703                 query.append(orderByFields[i]);
704 
705                 if ((i + 1) < orderByFields.length) {
706                     if (orderByComparator.isAscending() ^ previous) {
707                         query.append(ORDER_BY_ASC_HAS_NEXT);
708                     }
709                     else {
710                         query.append(ORDER_BY_DESC_HAS_NEXT);
711                     }
712                 }
713                 else {
714                     if (orderByComparator.isAscending() ^ previous) {
715                         query.append(ORDER_BY_ASC);
716                     }
717                     else {
718                         query.append(ORDER_BY_DESC);
719                     }
720                 }
721             }
722         }
723 
724         else {
725             query.append(IGFolderModelImpl.ORDER_BY_JPQL);
726         }
727 
728         String sql = query.toString();
729 
730         Query q = session.createQuery(sql);
731 
732         q.setFirstResult(0);
733         q.setMaxResults(2);
734 
735         QueryPos qPos = QueryPos.getInstance(q);
736 
737         if (uuid != null) {
738             qPos.add(uuid);
739         }
740 
741         if (orderByComparator != null) {
742             Object[] values = orderByComparator.getOrderByValues(igFolder);
743 
744             for (Object value : values) {
745                 qPos.add(value);
746             }
747         }
748 
749         List<IGFolder> list = q.list();
750 
751         if (list.size() == 2) {
752             return list.get(1);
753         }
754         else {
755             return null;
756         }
757     }
758 
759     public IGFolder findByUUID_G(String uuid, long groupId)
760         throws NoSuchFolderException, SystemException {
761         IGFolder igFolder = fetchByUUID_G(uuid, groupId);
762 
763         if (igFolder == null) {
764             StringBundler msg = new StringBundler(6);
765 
766             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
767 
768             msg.append("uuid=");
769             msg.append(uuid);
770 
771             msg.append(", groupId=");
772             msg.append(groupId);
773 
774             msg.append(StringPool.CLOSE_CURLY_BRACE);
775 
776             if (_log.isWarnEnabled()) {
777                 _log.warn(msg.toString());
778             }
779 
780             throw new NoSuchFolderException(msg.toString());
781         }
782 
783         return igFolder;
784     }
785 
786     public IGFolder fetchByUUID_G(String uuid, long groupId)
787         throws SystemException {
788         return fetchByUUID_G(uuid, groupId, true);
789     }
790 
791     public IGFolder fetchByUUID_G(String uuid, long groupId,
792         boolean retrieveFromCache) throws SystemException {
793         Object[] finderArgs = new Object[] { uuid, groupId };
794 
795         Object result = null;
796 
797         if (retrieveFromCache) {
798             result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_UUID_G,
799                     finderArgs, this);
800         }
801 
802         if (result == null) {
803             StringBundler query = new StringBundler(4);
804 
805             query.append(_SQL_SELECT_IGFOLDER_WHERE);
806 
807             if (uuid == null) {
808                 query.append(_FINDER_COLUMN_UUID_G_UUID_1);
809             }
810             else {
811                 if (uuid.equals(StringPool.BLANK)) {
812                     query.append(_FINDER_COLUMN_UUID_G_UUID_3);
813                 }
814                 else {
815                     query.append(_FINDER_COLUMN_UUID_G_UUID_2);
816                 }
817             }
818 
819             query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
820 
821             query.append(IGFolderModelImpl.ORDER_BY_JPQL);
822 
823             String sql = query.toString();
824 
825             Session session = null;
826 
827             try {
828                 session = openSession();
829 
830                 Query q = session.createQuery(sql);
831 
832                 QueryPos qPos = QueryPos.getInstance(q);
833 
834                 if (uuid != null) {
835                     qPos.add(uuid);
836                 }
837 
838                 qPos.add(groupId);
839 
840                 List<IGFolder> list = q.list();
841 
842                 result = list;
843 
844                 IGFolder igFolder = null;
845 
846                 if (list.isEmpty()) {
847                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
848                         finderArgs, list);
849                 }
850                 else {
851                     igFolder = list.get(0);
852 
853                     cacheResult(igFolder);
854 
855                     if ((igFolder.getUuid() == null) ||
856                             !igFolder.getUuid().equals(uuid) ||
857                             (igFolder.getGroupId() != groupId)) {
858                         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
859                             finderArgs, igFolder);
860                     }
861                 }
862 
863                 return igFolder;
864             }
865             catch (Exception e) {
866                 throw processException(e);
867             }
868             finally {
869                 if (result == null) {
870                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
871                         finderArgs, new ArrayList<IGFolder>());
872                 }
873 
874                 closeSession(session);
875             }
876         }
877         else {
878             if (result instanceof List<?>) {
879                 return null;
880             }
881             else {
882                 return (IGFolder)result;
883             }
884         }
885     }
886 
887     public List<IGFolder> findByGroupId(long groupId) throws SystemException {
888         return findByGroupId(groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
889     }
890 
891     public List<IGFolder> findByGroupId(long groupId, int start, int end)
892         throws SystemException {
893         return findByGroupId(groupId, start, end, null);
894     }
895 
896     public List<IGFolder> findByGroupId(long groupId, int start, int end,
897         OrderByComparator orderByComparator) throws SystemException {
898         Object[] finderArgs = new Object[] {
899                 groupId,
900                 
901                 String.valueOf(start), String.valueOf(end),
902                 String.valueOf(orderByComparator)
903             };
904 
905         List<IGFolder> list = (List<IGFolder>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_GROUPID,
906                 finderArgs, this);
907 
908         if (list == null) {
909             StringBundler query = null;
910 
911             if (orderByComparator != null) {
912                 query = new StringBundler(3 +
913                         (orderByComparator.getOrderByFields().length * 3));
914             }
915             else {
916                 query = new StringBundler(3);
917             }
918 
919             query.append(_SQL_SELECT_IGFOLDER_WHERE);
920 
921             query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
922 
923             if (orderByComparator != null) {
924                 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
925                     orderByComparator);
926             }
927 
928             else {
929                 query.append(IGFolderModelImpl.ORDER_BY_JPQL);
930             }
931 
932             String sql = query.toString();
933 
934             Session session = null;
935 
936             try {
937                 session = openSession();
938 
939                 Query q = session.createQuery(sql);
940 
941                 QueryPos qPos = QueryPos.getInstance(q);
942 
943                 qPos.add(groupId);
944 
945                 list = (List<IGFolder>)QueryUtil.list(q, getDialect(), start,
946                         end);
947             }
948             catch (Exception e) {
949                 throw processException(e);
950             }
951             finally {
952                 if (list == null) {
953                     list = new ArrayList<IGFolder>();
954                 }
955 
956                 cacheResult(list);
957 
958                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_GROUPID,
959                     finderArgs, list);
960 
961                 closeSession(session);
962             }
963         }
964 
965         return list;
966     }
967 
968     public IGFolder findByGroupId_First(long groupId,
969         OrderByComparator orderByComparator)
970         throws NoSuchFolderException, SystemException {
971         List<IGFolder> list = findByGroupId(groupId, 0, 1, orderByComparator);
972 
973         if (list.isEmpty()) {
974             StringBundler msg = new StringBundler(4);
975 
976             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
977 
978             msg.append("groupId=");
979             msg.append(groupId);
980 
981             msg.append(StringPool.CLOSE_CURLY_BRACE);
982 
983             throw new NoSuchFolderException(msg.toString());
984         }
985         else {
986             return list.get(0);
987         }
988     }
989 
990     public IGFolder findByGroupId_Last(long groupId,
991         OrderByComparator orderByComparator)
992         throws NoSuchFolderException, SystemException {
993         int count = countByGroupId(groupId);
994 
995         List<IGFolder> list = findByGroupId(groupId, count - 1, count,
996                 orderByComparator);
997 
998         if (list.isEmpty()) {
999             StringBundler msg = new StringBundler(4);
1000
1001            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1002
1003            msg.append("groupId=");
1004            msg.append(groupId);
1005
1006            msg.append(StringPool.CLOSE_CURLY_BRACE);
1007
1008            throw new NoSuchFolderException(msg.toString());
1009        }
1010        else {
1011            return list.get(0);
1012        }
1013    }
1014
1015    public IGFolder[] findByGroupId_PrevAndNext(long folderId, long groupId,
1016        OrderByComparator orderByComparator)
1017        throws NoSuchFolderException, SystemException {
1018        IGFolder igFolder = findByPrimaryKey(folderId);
1019
1020        Session session = null;
1021
1022        try {
1023            session = openSession();
1024
1025            IGFolder[] array = new IGFolderImpl[3];
1026
1027            array[0] = getByGroupId_PrevAndNext(session, igFolder, groupId,
1028                    orderByComparator, true);
1029
1030            array[1] = igFolder;
1031
1032            array[2] = getByGroupId_PrevAndNext(session, igFolder, groupId,
1033                    orderByComparator, false);
1034
1035            return array;
1036        }
1037        catch (Exception e) {
1038            throw processException(e);
1039        }
1040        finally {
1041            closeSession(session);
1042        }
1043    }
1044
1045    protected IGFolder getByGroupId_PrevAndNext(Session session,
1046        IGFolder igFolder, long groupId, OrderByComparator orderByComparator,
1047        boolean previous) {
1048        StringBundler query = null;
1049
1050        if (orderByComparator != null) {
1051            query = new StringBundler(6 +
1052                    (orderByComparator.getOrderByFields().length * 6));
1053        }
1054        else {
1055            query = new StringBundler(3);
1056        }
1057
1058        query.append(_SQL_SELECT_IGFOLDER_WHERE);
1059
1060        query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1061
1062        if (orderByComparator != null) {
1063            String[] orderByFields = orderByComparator.getOrderByFields();
1064
1065            if (orderByFields.length > 0) {
1066                query.append(WHERE_AND);
1067            }
1068
1069            for (int i = 0; i < orderByFields.length; i++) {
1070                query.append(_ORDER_BY_ENTITY_ALIAS);
1071                query.append(orderByFields[i]);
1072
1073                if ((i + 1) < orderByFields.length) {
1074                    if (orderByComparator.isAscending() ^ previous) {
1075                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
1076                    }
1077                    else {
1078                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
1079                    }
1080                }
1081                else {
1082                    if (orderByComparator.isAscending() ^ previous) {
1083                        query.append(WHERE_GREATER_THAN);
1084                    }
1085                    else {
1086                        query.append(WHERE_LESSER_THAN);
1087                    }
1088                }
1089            }
1090
1091            query.append(ORDER_BY_CLAUSE);
1092
1093            for (int i = 0; i < orderByFields.length; i++) {
1094                query.append(_ORDER_BY_ENTITY_ALIAS);
1095                query.append(orderByFields[i]);
1096
1097                if ((i + 1) < orderByFields.length) {
1098                    if (orderByComparator.isAscending() ^ previous) {
1099                        query.append(ORDER_BY_ASC_HAS_NEXT);
1100                    }
1101                    else {
1102                        query.append(ORDER_BY_DESC_HAS_NEXT);
1103                    }
1104                }
1105                else {
1106                    if (orderByComparator.isAscending() ^ previous) {
1107                        query.append(ORDER_BY_ASC);
1108                    }
1109                    else {
1110                        query.append(ORDER_BY_DESC);
1111                    }
1112                }
1113            }
1114        }
1115
1116        else {
1117            query.append(IGFolderModelImpl.ORDER_BY_JPQL);
1118        }
1119
1120        String sql = query.toString();
1121
1122        Query q = session.createQuery(sql);
1123
1124        q.setFirstResult(0);
1125        q.setMaxResults(2);
1126
1127        QueryPos qPos = QueryPos.getInstance(q);
1128
1129        qPos.add(groupId);
1130
1131        if (orderByComparator != null) {
1132            Object[] values = orderByComparator.getOrderByValues(igFolder);
1133
1134            for (Object value : values) {
1135                qPos.add(value);
1136            }
1137        }
1138
1139        List<IGFolder> list = q.list();
1140
1141        if (list.size() == 2) {
1142            return list.get(1);
1143        }
1144        else {
1145            return null;
1146        }
1147    }
1148
1149    public List<IGFolder> findByCompanyId(long companyId)
1150        throws SystemException {
1151        return findByCompanyId(companyId, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
1152            null);
1153    }
1154
1155    public List<IGFolder> findByCompanyId(long companyId, int start, int end)
1156        throws SystemException {
1157        return findByCompanyId(companyId, start, end, null);
1158    }
1159
1160    public List<IGFolder> findByCompanyId(long companyId, int start, int end,
1161        OrderByComparator orderByComparator) throws SystemException {
1162        Object[] finderArgs = new Object[] {
1163                companyId,
1164                
1165                String.valueOf(start), String.valueOf(end),
1166                String.valueOf(orderByComparator)
1167            };
1168
1169        List<IGFolder> list = (List<IGFolder>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_COMPANYID,
1170                finderArgs, this);
1171
1172        if (list == null) {
1173            StringBundler query = null;
1174
1175            if (orderByComparator != null) {
1176                query = new StringBundler(3 +
1177                        (orderByComparator.getOrderByFields().length * 3));
1178            }
1179            else {
1180                query = new StringBundler(3);
1181            }
1182
1183            query.append(_SQL_SELECT_IGFOLDER_WHERE);
1184
1185            query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
1186
1187            if (orderByComparator != null) {
1188                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1189                    orderByComparator);
1190            }
1191
1192            else {
1193                query.append(IGFolderModelImpl.ORDER_BY_JPQL);
1194            }
1195
1196            String sql = query.toString();
1197
1198            Session session = null;
1199
1200            try {
1201                session = openSession();
1202
1203                Query q = session.createQuery(sql);
1204
1205                QueryPos qPos = QueryPos.getInstance(q);
1206
1207                qPos.add(companyId);
1208
1209                list = (List<IGFolder>)QueryUtil.list(q, getDialect(), start,
1210                        end);
1211            }
1212            catch (Exception e) {
1213                throw processException(e);
1214            }
1215            finally {
1216                if (list == null) {
1217                    list = new ArrayList<IGFolder>();
1218                }
1219
1220                cacheResult(list);
1221
1222                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_COMPANYID,
1223                    finderArgs, list);
1224
1225                closeSession(session);
1226            }
1227        }
1228
1229        return list;
1230    }
1231
1232    public IGFolder findByCompanyId_First(long companyId,
1233        OrderByComparator orderByComparator)
1234        throws NoSuchFolderException, SystemException {
1235        List<IGFolder> list = findByCompanyId(companyId, 0, 1, orderByComparator);
1236
1237        if (list.isEmpty()) {
1238            StringBundler msg = new StringBundler(4);
1239
1240            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1241
1242            msg.append("companyId=");
1243            msg.append(companyId);
1244
1245            msg.append(StringPool.CLOSE_CURLY_BRACE);
1246
1247            throw new NoSuchFolderException(msg.toString());
1248        }
1249        else {
1250            return list.get(0);
1251        }
1252    }
1253
1254    public IGFolder findByCompanyId_Last(long companyId,
1255        OrderByComparator orderByComparator)
1256        throws NoSuchFolderException, SystemException {
1257        int count = countByCompanyId(companyId);
1258
1259        List<IGFolder> list = findByCompanyId(companyId, count - 1, count,
1260                orderByComparator);
1261
1262        if (list.isEmpty()) {
1263            StringBundler msg = new StringBundler(4);
1264
1265            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1266
1267            msg.append("companyId=");
1268            msg.append(companyId);
1269
1270            msg.append(StringPool.CLOSE_CURLY_BRACE);
1271
1272            throw new NoSuchFolderException(msg.toString());
1273        }
1274        else {
1275            return list.get(0);
1276        }
1277    }
1278
1279    public IGFolder[] findByCompanyId_PrevAndNext(long folderId,
1280        long companyId, OrderByComparator orderByComparator)
1281        throws NoSuchFolderException, SystemException {
1282        IGFolder igFolder = findByPrimaryKey(folderId);
1283
1284        Session session = null;
1285
1286        try {
1287            session = openSession();
1288
1289            IGFolder[] array = new IGFolderImpl[3];
1290
1291            array[0] = getByCompanyId_PrevAndNext(session, igFolder, companyId,
1292                    orderByComparator, true);
1293
1294            array[1] = igFolder;
1295
1296            array[2] = getByCompanyId_PrevAndNext(session, igFolder, companyId,
1297                    orderByComparator, false);
1298
1299            return array;
1300        }
1301        catch (Exception e) {
1302            throw processException(e);
1303        }
1304        finally {
1305            closeSession(session);
1306        }
1307    }
1308
1309    protected IGFolder getByCompanyId_PrevAndNext(Session session,
1310        IGFolder igFolder, long companyId, OrderByComparator orderByComparator,
1311        boolean previous) {
1312        StringBundler query = null;
1313
1314        if (orderByComparator != null) {
1315            query = new StringBundler(6 +
1316                    (orderByComparator.getOrderByFields().length * 6));
1317        }
1318        else {
1319            query = new StringBundler(3);
1320        }
1321
1322        query.append(_SQL_SELECT_IGFOLDER_WHERE);
1323
1324        query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
1325
1326        if (orderByComparator != null) {
1327            String[] orderByFields = orderByComparator.getOrderByFields();
1328
1329            if (orderByFields.length > 0) {
1330                query.append(WHERE_AND);
1331            }
1332
1333            for (int i = 0; i < orderByFields.length; i++) {
1334                query.append(_ORDER_BY_ENTITY_ALIAS);
1335                query.append(orderByFields[i]);
1336
1337                if ((i + 1) < orderByFields.length) {
1338                    if (orderByComparator.isAscending() ^ previous) {
1339                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
1340                    }
1341                    else {
1342                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
1343                    }
1344                }
1345                else {
1346                    if (orderByComparator.isAscending() ^ previous) {
1347                        query.append(WHERE_GREATER_THAN);
1348                    }
1349                    else {
1350                        query.append(WHERE_LESSER_THAN);
1351                    }
1352                }
1353            }
1354
1355            query.append(ORDER_BY_CLAUSE);
1356
1357            for (int i = 0; i < orderByFields.length; i++) {
1358                query.append(_ORDER_BY_ENTITY_ALIAS);
1359                query.append(orderByFields[i]);
1360
1361                if ((i + 1) < orderByFields.length) {
1362                    if (orderByComparator.isAscending() ^ previous) {
1363                        query.append(ORDER_BY_ASC_HAS_NEXT);
1364                    }
1365                    else {
1366                        query.append(ORDER_BY_DESC_HAS_NEXT);
1367                    }
1368                }
1369                else {
1370                    if (orderByComparator.isAscending() ^ previous) {
1371                        query.append(ORDER_BY_ASC);
1372                    }
1373                    else {
1374                        query.append(ORDER_BY_DESC);
1375                    }
1376                }
1377            }
1378        }
1379
1380        else {
1381            query.append(IGFolderModelImpl.ORDER_BY_JPQL);
1382        }
1383
1384        String sql = query.toString();
1385
1386        Query q = session.createQuery(sql);
1387
1388        q.setFirstResult(0);
1389        q.setMaxResults(2);
1390
1391        QueryPos qPos = QueryPos.getInstance(q);
1392
1393        qPos.add(companyId);
1394
1395        if (orderByComparator != null) {
1396            Object[] values = orderByComparator.getOrderByValues(igFolder);
1397
1398            for (Object value : values) {
1399                qPos.add(value);
1400            }
1401        }
1402
1403        List<IGFolder> list = q.list();
1404
1405        if (list.size() == 2) {
1406            return list.get(1);
1407        }
1408        else {
1409            return null;
1410        }
1411    }
1412
1413    public List<IGFolder> findByG_P(long groupId, long parentFolderId)
1414        throws SystemException {
1415        return findByG_P(groupId, parentFolderId, QueryUtil.ALL_POS,
1416            QueryUtil.ALL_POS, null);
1417    }
1418
1419    public List<IGFolder> findByG_P(long groupId, long parentFolderId,
1420        int start, int end) throws SystemException {
1421        return findByG_P(groupId, parentFolderId, start, end, null);
1422    }
1423
1424    public List<IGFolder> findByG_P(long groupId, long parentFolderId,
1425        int start, int end, OrderByComparator orderByComparator)
1426        throws SystemException {
1427        Object[] finderArgs = new Object[] {
1428                groupId, parentFolderId,
1429                
1430                String.valueOf(start), String.valueOf(end),
1431                String.valueOf(orderByComparator)
1432            };
1433
1434        List<IGFolder> list = (List<IGFolder>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_P,
1435                finderArgs, this);
1436
1437        if (list == null) {
1438            StringBundler query = null;
1439
1440            if (orderByComparator != null) {
1441                query = new StringBundler(4 +
1442                        (orderByComparator.getOrderByFields().length * 3));
1443            }
1444            else {
1445                query = new StringBundler(4);
1446            }
1447
1448            query.append(_SQL_SELECT_IGFOLDER_WHERE);
1449
1450            query.append(_FINDER_COLUMN_G_P_GROUPID_2);
1451
1452            query.append(_FINDER_COLUMN_G_P_PARENTFOLDERID_2);
1453
1454            if (orderByComparator != null) {
1455                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1456                    orderByComparator);
1457            }
1458
1459            else {
1460                query.append(IGFolderModelImpl.ORDER_BY_JPQL);
1461            }
1462
1463            String sql = query.toString();
1464
1465            Session session = null;
1466
1467            try {
1468                session = openSession();
1469
1470                Query q = session.createQuery(sql);
1471
1472                QueryPos qPos = QueryPos.getInstance(q);
1473
1474                qPos.add(groupId);
1475
1476                qPos.add(parentFolderId);
1477
1478                list = (List<IGFolder>)QueryUtil.list(q, getDialect(), start,
1479                        end);
1480            }
1481            catch (Exception e) {
1482                throw processException(e);
1483            }
1484            finally {
1485                if (list == null) {
1486                    list = new ArrayList<IGFolder>();
1487                }
1488
1489                cacheResult(list);
1490
1491                FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_P, finderArgs,
1492                    list);
1493
1494                closeSession(session);
1495            }
1496        }
1497
1498        return list;
1499    }
1500
1501    public IGFolder findByG_P_First(long groupId, long parentFolderId,
1502        OrderByComparator orderByComparator)
1503        throws NoSuchFolderException, SystemException {
1504        List<IGFolder> list = findByG_P(groupId, parentFolderId, 0, 1,
1505                orderByComparator);
1506
1507        if (list.isEmpty()) {
1508            StringBundler msg = new StringBundler(6);
1509
1510            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1511
1512            msg.append("groupId=");
1513            msg.append(groupId);
1514
1515            msg.append(", parentFolderId=");
1516            msg.append(parentFolderId);
1517
1518            msg.append(StringPool.CLOSE_CURLY_BRACE);
1519
1520            throw new NoSuchFolderException(msg.toString());
1521        }
1522        else {
1523            return list.get(0);
1524        }
1525    }
1526
1527    public IGFolder findByG_P_Last(long groupId, long parentFolderId,
1528        OrderByComparator orderByComparator)
1529        throws NoSuchFolderException, SystemException {
1530        int count = countByG_P(groupId, parentFolderId);
1531
1532        List<IGFolder> list = findByG_P(groupId, parentFolderId, count - 1,
1533                count, orderByComparator);
1534
1535        if (list.isEmpty()) {
1536            StringBundler msg = new StringBundler(6);
1537
1538            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1539
1540            msg.append("groupId=");
1541            msg.append(groupId);
1542
1543            msg.append(", parentFolderId=");
1544            msg.append(parentFolderId);
1545
1546            msg.append(StringPool.CLOSE_CURLY_BRACE);
1547
1548            throw new NoSuchFolderException(msg.toString());
1549        }
1550        else {
1551            return list.get(0);
1552        }
1553    }
1554
1555    public IGFolder[] findByG_P_PrevAndNext(long folderId, long groupId,
1556        long parentFolderId, OrderByComparator orderByComparator)
1557        throws NoSuchFolderException, SystemException {
1558        IGFolder igFolder = findByPrimaryKey(folderId);
1559
1560        Session session = null;
1561
1562        try {
1563            session = openSession();
1564
1565            IGFolder[] array = new IGFolderImpl[3];
1566
1567            array[0] = getByG_P_PrevAndNext(session, igFolder, groupId,
1568                    parentFolderId, orderByComparator, true);
1569
1570            array[1] = igFolder;
1571
1572            array[2] = getByG_P_PrevAndNext(session, igFolder, groupId,
1573                    parentFolderId, orderByComparator, false);
1574
1575            return array;
1576        }
1577        catch (Exception e) {
1578            throw processException(e);
1579        }
1580        finally {
1581            closeSession(session);
1582        }
1583    }
1584
1585    protected IGFolder getByG_P_PrevAndNext(Session session, IGFolder igFolder,
1586        long groupId, long parentFolderId, OrderByComparator orderByComparator,
1587        boolean previous) {
1588        StringBundler query = null;
1589
1590        if (orderByComparator != null) {
1591            query = new StringBundler(6 +
1592                    (orderByComparator.getOrderByFields().length * 6));
1593        }
1594        else {
1595            query = new StringBundler(3);
1596        }
1597
1598        query.append(_SQL_SELECT_IGFOLDER_WHERE);
1599
1600        query.append(_FINDER_COLUMN_G_P_GROUPID_2);
1601
1602        query.append(_FINDER_COLUMN_G_P_PARENTFOLDERID_2);
1603
1604        if (orderByComparator != null) {
1605            String[] orderByFields = orderByComparator.getOrderByFields();
1606
1607            if (orderByFields.length > 0) {
1608                query.append(WHERE_AND);
1609            }
1610
1611            for (int i = 0; i < orderByFields.length; i++) {
1612                query.append(_ORDER_BY_ENTITY_ALIAS);
1613                query.append(orderByFields[i]);
1614
1615                if ((i + 1) < orderByFields.length) {
1616                    if (orderByComparator.isAscending() ^ previous) {
1617                        query.append(WHERE_GREATER_THAN_HAS_NEXT);
1618                    }
1619                    else {
1620                        query.append(WHERE_LESSER_THAN_HAS_NEXT);
1621                    }
1622                }
1623                else {
1624                    if (orderByComparator.isAscending() ^ previous) {
1625                        query.append(WHERE_GREATER_THAN);
1626                    }
1627                    else {
1628                        query.append(WHERE_LESSER_THAN);
1629                    }
1630                }
1631            }
1632
1633            query.append(ORDER_BY_CLAUSE);
1634
1635            for (int i = 0; i < orderByFields.length; i++) {
1636                query.append(_ORDER_BY_ENTITY_ALIAS);
1637                query.append(orderByFields[i]);
1638
1639                if ((i + 1) < orderByFields.length) {
1640                    if (orderByComparator.isAscending() ^ previous) {
1641                        query.append(ORDER_BY_ASC_HAS_NEXT);
1642                    }
1643                    else {
1644                        query.append(ORDER_BY_DESC_HAS_NEXT);
1645                    }
1646                }
1647                else {
1648                    if (orderByComparator.isAscending() ^ previous) {
1649                        query.append(ORDER_BY_ASC);
1650                    }
1651                    else {
1652                        query.append(ORDER_BY_DESC);
1653                    }
1654                }
1655            }
1656        }
1657
1658        else {
1659            query.append(IGFolderModelImpl.ORDER_BY_JPQL);
1660        }
1661
1662        String sql = query.toString();
1663
1664        Query q = session.createQuery(sql);
1665
1666        q.setFirstResult(0);
1667        q.setMaxResults(2);
1668
1669        QueryPos qPos = QueryPos.getInstance(q);
1670
1671        qPos.add(groupId);
1672
1673        qPos.add(parentFolderId);
1674
1675        if (orderByComparator != null) {
1676            Object[] values = orderByComparator.getOrderByValues(igFolder);
1677
1678            for (Object value : values) {
1679                qPos.add(value);
1680            }
1681        }
1682
1683        List<IGFolder> list = q.list();
1684
1685        if (list.size() == 2) {
1686            return list.get(1);
1687        }
1688        else {
1689            return null;
1690        }
1691    }
1692
1693    public IGFolder findByG_P_N(long groupId, long parentFolderId, String name)
1694        throws NoSuchFolderException, SystemException {
1695        IGFolder igFolder = fetchByG_P_N(groupId, parentFolderId, name);
1696
1697        if (igFolder == null) {
1698            StringBundler msg = new StringBundler(8);
1699
1700            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1701
1702            msg.append("groupId=");
1703            msg.append(groupId);
1704
1705            msg.append(", parentFolderId=");
1706            msg.append(parentFolderId);
1707
1708            msg.append(", name=");
1709            msg.append(name);
1710
1711            msg.append(StringPool.CLOSE_CURLY_BRACE);
1712
1713            if (_log.isWarnEnabled()) {
1714                _log.warn(msg.toString());
1715            }
1716
1717            throw new NoSuchFolderException(msg.toString());
1718        }
1719
1720        return igFolder;
1721    }
1722
1723    public IGFolder fetchByG_P_N(long groupId, long parentFolderId, String name)
1724        throws SystemException {
1725        return fetchByG_P_N(groupId, parentFolderId, name, true);
1726    }
1727
1728    public IGFolder fetchByG_P_N(long groupId, long parentFolderId,
1729        String name, boolean retrieveFromCache) throws SystemException {
1730        Object[] finderArgs = new Object[] { groupId, parentFolderId, name };
1731
1732        Object result = null;
1733
1734        if (retrieveFromCache) {
1735            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_G_P_N,
1736                    finderArgs, this);
1737        }
1738
1739        if (result == null) {
1740            StringBundler query = new StringBundler(5);
1741
1742            query.append(_SQL_SELECT_IGFOLDER_WHERE);
1743
1744            query.append(_FINDER_COLUMN_G_P_N_GROUPID_2);
1745
1746            query.append(_FINDER_COLUMN_G_P_N_PARENTFOLDERID_2);
1747
1748            if (name == null) {
1749                query.append(_FINDER_COLUMN_G_P_N_NAME_1);
1750            }
1751            else {
1752                if (name.equals(StringPool.BLANK)) {
1753                    query.append(_FINDER_COLUMN_G_P_N_NAME_3);
1754                }
1755                else {
1756                    query.append(_FINDER_COLUMN_G_P_N_NAME_2);
1757                }
1758            }
1759
1760            query.append(IGFolderModelImpl.ORDER_BY_JPQL);
1761
1762            String sql = query.toString();
1763
1764            Session session = null;
1765
1766            try {
1767                session = openSession();
1768
1769                Query q = session.createQuery(sql);
1770
1771                QueryPos qPos = QueryPos.getInstance(q);
1772
1773                qPos.add(groupId);
1774
1775                qPos.add(parentFolderId);
1776
1777                if (name != null) {
1778                    qPos.add(name);
1779                }
1780
1781                List<IGFolder> list = q.list();
1782
1783                result = list;
1784
1785                IGFolder igFolder = null;
1786
1787                if (list.isEmpty()) {
1788                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_P_N,
1789                        finderArgs, list);
1790                }
1791                else {
1792                    igFolder = list.get(0);
1793
1794                    cacheResult(igFolder);
1795
1796                    if ((igFolder.getGroupId() != groupId) ||
1797                            (igFolder.getParentFolderId() != parentFolderId) ||
1798                            (igFolder.getName() == null) ||
1799                            !igFolder.getName().equals(name)) {
1800                        FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_P_N,
1801                            finderArgs, igFolder);
1802                    }
1803                }
1804
1805                return igFolder;
1806            }
1807            catch (Exception e) {
1808                throw processException(e);
1809            }
1810            finally {
1811                if (result == null) {
1812                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_P_N,
1813                        finderArgs, new ArrayList<IGFolder>());
1814                }
1815
1816                closeSession(session);
1817            }
1818        }
1819        else {
1820            if (result instanceof List<?>) {
1821                return null;
1822            }
1823            else {
1824                return (IGFolder)result;
1825            }
1826        }
1827    }
1828
1829    public List<IGFolder> findAll() throws SystemException {
1830        return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1831    }
1832
1833    public List<IGFolder> findAll(int start, int end) throws SystemException {
1834        return findAll(start, end, null);
1835    }
1836
1837    public List<IGFolder> findAll(int start, int end,
1838        OrderByComparator orderByComparator) throws SystemException {
1839        Object[] finderArgs = new Object[] {
1840                String.valueOf(start), String.valueOf(end),
1841                String.valueOf(orderByComparator)
1842            };
1843
1844        List<IGFolder> list = (List<IGFolder>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
1845                finderArgs, this);
1846
1847        if (list == null) {
1848            StringBundler query = null;
1849            String sql = null;
1850
1851            if (orderByComparator != null) {
1852                query = new StringBundler(2 +
1853                        (orderByComparator.getOrderByFields().length * 3));
1854
1855                query.append(_SQL_SELECT_IGFOLDER);
1856
1857                appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1858                    orderByComparator);
1859
1860                sql = query.toString();
1861            }
1862            else {
1863                sql = _SQL_SELECT_IGFOLDER.concat(IGFolderModelImpl.ORDER_BY_JPQL);
1864            }
1865
1866            Session session = null;
1867
1868            try {
1869                session = openSession();
1870
1871                Query q = session.createQuery(sql);
1872
1873                if (orderByComparator == null) {
1874                    list = (List<IGFolder>)QueryUtil.list(q, getDialect(),
1875                            start, end, false);
1876
1877                    Collections.sort(list);
1878                }
1879                else {
1880                    list = (List<IGFolder>)QueryUtil.list(q, getDialect(),
1881                            start, end);
1882                }
1883            }
1884            catch (Exception e) {
1885                throw processException(e);
1886            }
1887            finally {
1888                if (list == null) {
1889                    list = new ArrayList<IGFolder>();
1890                }
1891
1892                cacheResult(list);
1893
1894                FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
1895
1896                closeSession(session);
1897            }
1898        }
1899
1900        return list;
1901    }
1902
1903    public void removeByUuid(String uuid) throws SystemException {
1904        for (IGFolder igFolder : findByUuid(uuid)) {
1905            remove(igFolder);
1906        }
1907    }
1908
1909    public void removeByUUID_G(String uuid, long groupId)
1910        throws NoSuchFolderException, SystemException {
1911        IGFolder igFolder = findByUUID_G(uuid, groupId);
1912
1913        remove(igFolder);
1914    }
1915
1916    public void removeByGroupId(long groupId) throws SystemException {
1917        for (IGFolder igFolder : findByGroupId(groupId)) {
1918            remove(igFolder);
1919        }
1920    }
1921
1922    public void removeByCompanyId(long companyId) throws SystemException {
1923        for (IGFolder igFolder : findByCompanyId(companyId)) {
1924            remove(igFolder);
1925        }
1926    }
1927
1928    public void removeByG_P(long groupId, long parentFolderId)
1929        throws SystemException {
1930        for (IGFolder igFolder : findByG_P(groupId, parentFolderId)) {
1931            remove(igFolder);
1932        }
1933    }
1934
1935    public void removeByG_P_N(long groupId, long parentFolderId, String name)
1936        throws NoSuchFolderException, SystemException {
1937        IGFolder igFolder = findByG_P_N(groupId, parentFolderId, name);
1938
1939        remove(igFolder);
1940    }
1941
1942    public void removeAll() throws SystemException {
1943        for (IGFolder igFolder : findAll()) {
1944            remove(igFolder);
1945        }
1946    }
1947
1948    public int countByUuid(String uuid) throws SystemException {
1949        Object[] finderArgs = new Object[] { uuid };
1950
1951        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_UUID,
1952                finderArgs, this);
1953
1954        if (count == null) {
1955            StringBundler query = new StringBundler(2);
1956
1957            query.append(_SQL_COUNT_IGFOLDER_WHERE);
1958
1959            if (uuid == null) {
1960                query.append(_FINDER_COLUMN_UUID_UUID_1);
1961            }
1962            else {
1963                if (uuid.equals(StringPool.BLANK)) {
1964                    query.append(_FINDER_COLUMN_UUID_UUID_3);
1965                }
1966                else {
1967                    query.append(_FINDER_COLUMN_UUID_UUID_2);
1968                }
1969            }
1970
1971            String sql = query.toString();
1972
1973            Session session = null;
1974
1975            try {
1976                session = openSession();
1977
1978                Query q = session.createQuery(sql);
1979
1980                QueryPos qPos = QueryPos.getInstance(q);
1981
1982                if (uuid != null) {
1983                    qPos.add(uuid);
1984                }
1985
1986                count = (Long)q.uniqueResult();
1987            }
1988            catch (Exception e) {
1989                throw processException(e);
1990            }
1991            finally {
1992                if (count == null) {
1993                    count = Long.valueOf(0);
1994                }
1995
1996                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID,
1997                    finderArgs, count);
1998
1999                closeSession(session);
2000            }
2001        }
2002
2003        return count.intValue();
2004    }
2005
2006    public int countByUUID_G(String uuid, long groupId)
2007        throws SystemException {
2008        Object[] finderArgs = new Object[] { uuid, groupId };
2009
2010        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_UUID_G,
2011                finderArgs, this);
2012
2013        if (count == null) {
2014            StringBundler query = new StringBundler(3);
2015
2016            query.append(_SQL_COUNT_IGFOLDER_WHERE);
2017
2018            if (uuid == null) {
2019                query.append(_FINDER_COLUMN_UUID_G_UUID_1);
2020            }
2021            else {
2022                if (uuid.equals(StringPool.BLANK)) {
2023                    query.append(_FINDER_COLUMN_UUID_G_UUID_3);
2024                }
2025                else {
2026                    query.append(_FINDER_COLUMN_UUID_G_UUID_2);
2027                }
2028            }
2029
2030            query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
2031
2032            String sql = query.toString();
2033
2034            Session session = null;
2035
2036            try {
2037                session = openSession();
2038
2039                Query q = session.createQuery(sql);
2040
2041                QueryPos qPos = QueryPos.getInstance(q);
2042
2043                if (uuid != null) {
2044                    qPos.add(uuid);
2045                }
2046
2047                qPos.add(groupId);
2048
2049                count = (Long)q.uniqueResult();
2050            }
2051            catch (Exception e) {
2052                throw processException(e);
2053            }
2054            finally {
2055                if (count == null) {
2056                    count = Long.valueOf(0);
2057                }
2058
2059                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID_G,
2060                    finderArgs, count);
2061
2062                closeSession(session);
2063            }
2064        }
2065
2066        return count.intValue();
2067    }
2068
2069    public int countByGroupId(long groupId) throws SystemException {
2070        Object[] finderArgs = new Object[] { groupId };
2071
2072        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_GROUPID,
2073                finderArgs, this);
2074
2075        if (count == null) {
2076            StringBundler query = new StringBundler(2);
2077
2078            query.append(_SQL_COUNT_IGFOLDER_WHERE);
2079
2080            query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
2081
2082            String sql = query.toString();
2083
2084            Session session = null;
2085
2086            try {
2087                session = openSession();
2088
2089                Query q = session.createQuery(sql);
2090
2091                QueryPos qPos = QueryPos.getInstance(q);
2092
2093                qPos.add(groupId);
2094
2095                count = (Long)q.uniqueResult();
2096            }
2097            catch (Exception e) {
2098                throw processException(e);
2099            }
2100            finally {
2101                if (count == null) {
2102                    count = Long.valueOf(0);
2103                }
2104
2105                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_GROUPID,
2106                    finderArgs, count);
2107
2108                closeSession(session);
2109            }
2110        }
2111
2112        return count.intValue();
2113    }
2114
2115    public int countByCompanyId(long companyId) throws SystemException {
2116        Object[] finderArgs = new Object[] { companyId };
2117
2118        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_COMPANYID,
2119                finderArgs, this);
2120
2121        if (count == null) {
2122            StringBundler query = new StringBundler(2);
2123
2124            query.append(_SQL_COUNT_IGFOLDER_WHERE);
2125
2126            query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
2127
2128            String sql = query.toString();
2129
2130            Session session = null;
2131
2132            try {
2133                session = openSession();
2134
2135                Query q = session.createQuery(sql);
2136
2137                QueryPos qPos = QueryPos.getInstance(q);
2138
2139                qPos.add(companyId);
2140
2141                count = (Long)q.uniqueResult();
2142            }
2143            catch (Exception e) {
2144                throw processException(e);
2145            }
2146            finally {
2147                if (count == null) {
2148                    count = Long.valueOf(0);
2149                }
2150
2151                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_COMPANYID,
2152                    finderArgs, count);
2153
2154                closeSession(session);
2155            }
2156        }
2157
2158        return count.intValue();
2159    }
2160
2161    public int countByG_P(long groupId, long parentFolderId)
2162        throws SystemException {
2163        Object[] finderArgs = new Object[] { groupId, parentFolderId };
2164
2165        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_P,
2166                finderArgs, this);
2167
2168        if (count == null) {
2169            StringBundler query = new StringBundler(3);
2170
2171            query.append(_SQL_COUNT_IGFOLDER_WHERE);
2172
2173            query.append(_FINDER_COLUMN_G_P_GROUPID_2);
2174
2175            query.append(_FINDER_COLUMN_G_P_PARENTFOLDERID_2);
2176
2177            String sql = query.toString();
2178
2179            Session session = null;
2180
2181            try {
2182                session = openSession();
2183
2184                Query q = session.createQuery(sql);
2185
2186                QueryPos qPos = QueryPos.getInstance(q);
2187
2188                qPos.add(groupId);
2189
2190                qPos.add(parentFolderId);
2191
2192                count = (Long)q.uniqueResult();
2193            }
2194            catch (Exception e) {
2195                throw processException(e);
2196            }
2197            finally {
2198                if (count == null) {
2199                    count = Long.valueOf(0);
2200                }
2201
2202                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_P, finderArgs,
2203                    count);
2204
2205                closeSession(session);
2206            }
2207        }
2208
2209        return count.intValue();
2210    }
2211
2212    public int countByG_P_N(long groupId, long parentFolderId, String name)
2213        throws SystemException {
2214        Object[] finderArgs = new Object[] { groupId, parentFolderId, name };
2215
2216        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_P_N,
2217                finderArgs, this);
2218
2219        if (count == null) {
2220            StringBundler query = new StringBundler(4);
2221
2222            query.append(_SQL_COUNT_IGFOLDER_WHERE);
2223
2224            query.append(_FINDER_COLUMN_G_P_N_GROUPID_2);
2225
2226            query.append(_FINDER_COLUMN_G_P_N_PARENTFOLDERID_2);
2227
2228            if (name == null) {
2229                query.append(_FINDER_COLUMN_G_P_N_NAME_1);
2230            }
2231            else {
2232                if (name.equals(StringPool.BLANK)) {
2233                    query.append(_FINDER_COLUMN_G_P_N_NAME_3);
2234                }
2235                else {
2236                    query.append(_FINDER_COLUMN_G_P_N_NAME_2);
2237                }
2238            }
2239
2240            String sql = query.toString();
2241
2242            Session session = null;
2243
2244            try {
2245                session = openSession();
2246
2247                Query q = session.createQuery(sql);
2248
2249                QueryPos qPos = QueryPos.getInstance(q);
2250
2251                qPos.add(groupId);
2252
2253                qPos.add(parentFolderId);
2254
2255                if (name != null) {
2256                    qPos.add(name);
2257                }
2258
2259                count = (Long)q.uniqueResult();
2260            }
2261            catch (Exception e) {
2262                throw processException(e);
2263            }
2264            finally {
2265                if (count == null) {
2266                    count = Long.valueOf(0);
2267                }
2268
2269                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_P_N,
2270                    finderArgs, count);
2271
2272                closeSession(session);
2273            }
2274        }
2275
2276        return count.intValue();
2277    }
2278
2279    public int countAll() throws SystemException {
2280        Object[] finderArgs = new Object[0];
2281
2282        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
2283                finderArgs, this);
2284
2285        if (count == null) {
2286            Session session = null;
2287
2288            try {
2289                session = openSession();
2290
2291                Query q = session.createQuery(_SQL_COUNT_IGFOLDER);
2292
2293                count = (Long)q.uniqueResult();
2294            }
2295            catch (Exception e) {
2296                throw processException(e);
2297            }
2298            finally {
2299                if (count == null) {
2300                    count = Long.valueOf(0);
2301                }
2302
2303                FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
2304                    count);
2305
2306                closeSession(session);
2307            }
2308        }
2309
2310        return count.intValue();
2311    }
2312
2313    public void afterPropertiesSet() {
2314        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
2315                    com.liferay.portal.util.PropsUtil.get(
2316                        "value.object.listener.com.liferay.portlet.imagegallery.model.IGFolder")));
2317
2318        if (listenerClassNames.length > 0) {
2319            try {
2320                List<ModelListener<IGFolder>> listenersList = new ArrayList<ModelListener<IGFolder>>();
2321
2322                for (String listenerClassName : listenerClassNames) {
2323                    listenersList.add((ModelListener<IGFolder>)InstanceFactory.newInstance(
2324                            listenerClassName));
2325                }
2326
2327                listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
2328            }
2329            catch (Exception e) {
2330                _log.error(e);
2331            }
2332        }
2333    }
2334
2335    public void destroy() {
2336        EntityCacheUtil.removeCache(IGFolderImpl.class.getName());
2337        FinderCacheUtil.removeCache(FINDER_CLASS_NAME_ENTITY);
2338        FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST);
2339    }
2340
2341    @BeanReference(type = IGFolderPersistence.class)
2342    protected IGFolderPersistence igFolderPersistence;
2343    @BeanReference(type = IGImagePersistence.class)
2344    protected IGImagePersistence igImagePersistence;
2345    @BeanReference(type = GroupPersistence.class)
2346    protected GroupPersistence groupPersistence;
2347    @BeanReference(type = ImagePersistence.class)
2348    protected ImagePersistence imagePersistence;
2349    @BeanReference(type = LayoutPersistence.class)
2350    protected LayoutPersistence layoutPersistence;
2351    @BeanReference(type = ResourcePersistence.class)
2352    protected ResourcePersistence resourcePersistence;
2353    @BeanReference(type = UserPersistence.class)
2354    protected UserPersistence userPersistence;
2355    @BeanReference(type = ExpandoValuePersistence.class)
2356    protected ExpandoValuePersistence expandoValuePersistence;
2357    private static final String _SQL_SELECT_IGFOLDER = "SELECT igFolder FROM IGFolder igFolder";
2358    private static final String _SQL_SELECT_IGFOLDER_WHERE = "SELECT igFolder FROM IGFolder igFolder WHERE ";
2359    private static final String _SQL_COUNT_IGFOLDER = "SELECT COUNT(igFolder) FROM IGFolder igFolder";
2360    private static final String _SQL_COUNT_IGFOLDER_WHERE = "SELECT COUNT(igFolder) FROM IGFolder igFolder WHERE ";
2361    private static final String _FINDER_COLUMN_UUID_UUID_1 = "igFolder.uuid IS NULL";
2362    private static final String _FINDER_COLUMN_UUID_UUID_2 = "igFolder.uuid = ?";
2363    private static final String _FINDER_COLUMN_UUID_UUID_3 = "(igFolder.uuid IS NULL OR igFolder.uuid = ?)";
2364    private static final String _FINDER_COLUMN_UUID_G_UUID_1 = "igFolder.uuid IS NULL AND ";
2365    private static final String _FINDER_COLUMN_UUID_G_UUID_2 = "igFolder.uuid = ? AND ";
2366    private static final String _FINDER_COLUMN_UUID_G_UUID_3 = "(igFolder.uuid IS NULL OR igFolder.uuid = ?) AND ";
2367    private static final String _FINDER_COLUMN_UUID_G_GROUPID_2 = "igFolder.groupId = ?";
2368    private static final String _FINDER_COLUMN_GROUPID_GROUPID_2 = "igFolder.groupId = ?";
2369    private static final String _FINDER_COLUMN_COMPANYID_COMPANYID_2 = "igFolder.companyId = ?";
2370    private static final String _FINDER_COLUMN_G_P_GROUPID_2 = "igFolder.groupId = ? AND ";
2371    private static final String _FINDER_COLUMN_G_P_PARENTFOLDERID_2 = "igFolder.parentFolderId = ?";
2372    private static final String _FINDER_COLUMN_G_P_N_GROUPID_2 = "igFolder.groupId = ? AND ";
2373    private static final String _FINDER_COLUMN_G_P_N_PARENTFOLDERID_2 = "igFolder.parentFolderId = ? AND ";
2374    private static final String _FINDER_COLUMN_G_P_N_NAME_1 = "igFolder.name IS NULL";
2375    private static final String _FINDER_COLUMN_G_P_N_NAME_2 = "igFolder.name = ?";
2376    private static final String _FINDER_COLUMN_G_P_N_NAME_3 = "(igFolder.name IS NULL OR igFolder.name = ?)";
2377    private static final String _ORDER_BY_ENTITY_ALIAS = "igFolder.";
2378    private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No IGFolder exists with the primary key ";
2379    private static final String _NO_SUCH_ENTITY_WITH_KEY = "No IGFolder exists with the key {";
2380    private static Log _log = LogFactoryUtil.getLog(IGFolderPersistenceImpl.class);
2381}