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.shopping.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.model.ModelListener;
37  import com.liferay.portal.service.persistence.BatchSessionUtil;
38  import com.liferay.portal.service.persistence.ResourcePersistence;
39  import com.liferay.portal.service.persistence.UserPersistence;
40  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
41  
42  import com.liferay.portlet.shopping.NoSuchCategoryException;
43  import com.liferay.portlet.shopping.model.ShoppingCategory;
44  import com.liferay.portlet.shopping.model.impl.ShoppingCategoryImpl;
45  import com.liferay.portlet.shopping.model.impl.ShoppingCategoryModelImpl;
46  
47  import java.io.Serializable;
48  
49  import java.util.ArrayList;
50  import java.util.Collections;
51  import java.util.List;
52  
53  /**
54   * <a href="ShoppingCategoryPersistenceImpl.java.html"><b><i>View Source</i></b></a>
55   *
56   * <p>
57   * ServiceBuilder generated this class. Modifications in this class will be
58   * overwritten the next time is generated.
59   * </p>
60   *
61   * @author    Brian Wing Shun Chan
62   * @see       ShoppingCategoryPersistence
63   * @see       ShoppingCategoryUtil
64   * @generated
65   */
66  public class ShoppingCategoryPersistenceImpl extends BasePersistenceImpl<ShoppingCategory>
67      implements ShoppingCategoryPersistence {
68      public static final String FINDER_CLASS_NAME_ENTITY = ShoppingCategoryImpl.class.getName();
69      public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
70          ".List";
71      public static final FinderPath FINDER_PATH_FIND_BY_GROUPID = new FinderPath(ShoppingCategoryModelImpl.ENTITY_CACHE_ENABLED,
72              ShoppingCategoryModelImpl.FINDER_CACHE_ENABLED,
73              FINDER_CLASS_NAME_LIST, "findByGroupId",
74              new String[] {
75                  Long.class.getName(),
76                  
77              "java.lang.Integer", "java.lang.Integer",
78                  "com.liferay.portal.kernel.util.OrderByComparator"
79              });
80      public static final FinderPath FINDER_PATH_COUNT_BY_GROUPID = new FinderPath(ShoppingCategoryModelImpl.ENTITY_CACHE_ENABLED,
81              ShoppingCategoryModelImpl.FINDER_CACHE_ENABLED,
82              FINDER_CLASS_NAME_LIST, "countByGroupId",
83              new String[] { Long.class.getName() });
84      public static final FinderPath FINDER_PATH_FIND_BY_G_P = new FinderPath(ShoppingCategoryModelImpl.ENTITY_CACHE_ENABLED,
85              ShoppingCategoryModelImpl.FINDER_CACHE_ENABLED,
86              FINDER_CLASS_NAME_LIST, "findByG_P",
87              new String[] {
88                  Long.class.getName(), Long.class.getName(),
89                  
90              "java.lang.Integer", "java.lang.Integer",
91                  "com.liferay.portal.kernel.util.OrderByComparator"
92              });
93      public static final FinderPath FINDER_PATH_COUNT_BY_G_P = new FinderPath(ShoppingCategoryModelImpl.ENTITY_CACHE_ENABLED,
94              ShoppingCategoryModelImpl.FINDER_CACHE_ENABLED,
95              FINDER_CLASS_NAME_LIST, "countByG_P",
96              new String[] { Long.class.getName(), Long.class.getName() });
97      public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(ShoppingCategoryModelImpl.ENTITY_CACHE_ENABLED,
98              ShoppingCategoryModelImpl.FINDER_CACHE_ENABLED,
99              FINDER_CLASS_NAME_LIST, "findAll", new String[0]);
100     public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(ShoppingCategoryModelImpl.ENTITY_CACHE_ENABLED,
101             ShoppingCategoryModelImpl.FINDER_CACHE_ENABLED,
102             FINDER_CLASS_NAME_LIST, "countAll", new String[0]);
103 
104     public void cacheResult(ShoppingCategory shoppingCategory) {
105         EntityCacheUtil.putResult(ShoppingCategoryModelImpl.ENTITY_CACHE_ENABLED,
106             ShoppingCategoryImpl.class, shoppingCategory.getPrimaryKey(),
107             shoppingCategory);
108     }
109 
110     public void cacheResult(List<ShoppingCategory> shoppingCategories) {
111         for (ShoppingCategory shoppingCategory : shoppingCategories) {
112             if (EntityCacheUtil.getResult(
113                         ShoppingCategoryModelImpl.ENTITY_CACHE_ENABLED,
114                         ShoppingCategoryImpl.class,
115                         shoppingCategory.getPrimaryKey(), this) == null) {
116                 cacheResult(shoppingCategory);
117             }
118         }
119     }
120 
121     public void clearCache() {
122         CacheRegistry.clear(ShoppingCategoryImpl.class.getName());
123         EntityCacheUtil.clearCache(ShoppingCategoryImpl.class.getName());
124         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
125         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
126     }
127 
128     public void clearCache(ShoppingCategory shoppingCategory) {
129         EntityCacheUtil.removeResult(ShoppingCategoryModelImpl.ENTITY_CACHE_ENABLED,
130             ShoppingCategoryImpl.class, shoppingCategory.getPrimaryKey());
131     }
132 
133     public ShoppingCategory create(long categoryId) {
134         ShoppingCategory shoppingCategory = new ShoppingCategoryImpl();
135 
136         shoppingCategory.setNew(true);
137         shoppingCategory.setPrimaryKey(categoryId);
138 
139         return shoppingCategory;
140     }
141 
142     public ShoppingCategory remove(Serializable primaryKey)
143         throws NoSuchModelException, SystemException {
144         return remove(((Long)primaryKey).longValue());
145     }
146 
147     public ShoppingCategory remove(long categoryId)
148         throws NoSuchCategoryException, SystemException {
149         Session session = null;
150 
151         try {
152             session = openSession();
153 
154             ShoppingCategory shoppingCategory = (ShoppingCategory)session.get(ShoppingCategoryImpl.class,
155                     new Long(categoryId));
156 
157             if (shoppingCategory == null) {
158                 if (_log.isWarnEnabled()) {
159                     _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + categoryId);
160                 }
161 
162                 throw new NoSuchCategoryException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
163                     categoryId);
164             }
165 
166             return remove(shoppingCategory);
167         }
168         catch (NoSuchCategoryException nsee) {
169             throw nsee;
170         }
171         catch (Exception e) {
172             throw processException(e);
173         }
174         finally {
175             closeSession(session);
176         }
177     }
178 
179     protected ShoppingCategory removeImpl(ShoppingCategory shoppingCategory)
180         throws SystemException {
181         shoppingCategory = toUnwrappedModel(shoppingCategory);
182 
183         Session session = null;
184 
185         try {
186             session = openSession();
187 
188             BatchSessionUtil.delete(session, shoppingCategory);
189         }
190         catch (Exception e) {
191             throw processException(e);
192         }
193         finally {
194             closeSession(session);
195         }
196 
197         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
198 
199         EntityCacheUtil.removeResult(ShoppingCategoryModelImpl.ENTITY_CACHE_ENABLED,
200             ShoppingCategoryImpl.class, shoppingCategory.getPrimaryKey());
201 
202         return shoppingCategory;
203     }
204 
205     /**
206      * @deprecated Use {@link BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)}.
207      */
208     public ShoppingCategory update(ShoppingCategory shoppingCategory)
209         throws SystemException {
210         if (_log.isWarnEnabled()) {
211             _log.warn(
212                 "Using the deprecated update(ShoppingCategory shoppingCategory) method. Use update(ShoppingCategory shoppingCategory, boolean merge) instead.");
213         }
214 
215         return update(shoppingCategory, false);
216     }
217 
218     public ShoppingCategory updateImpl(
219         com.liferay.portlet.shopping.model.ShoppingCategory shoppingCategory,
220         boolean merge) throws SystemException {
221         shoppingCategory = toUnwrappedModel(shoppingCategory);
222 
223         Session session = null;
224 
225         try {
226             session = openSession();
227 
228             BatchSessionUtil.update(session, shoppingCategory, merge);
229 
230             shoppingCategory.setNew(false);
231         }
232         catch (Exception e) {
233             throw processException(e);
234         }
235         finally {
236             closeSession(session);
237         }
238 
239         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
240 
241         EntityCacheUtil.putResult(ShoppingCategoryModelImpl.ENTITY_CACHE_ENABLED,
242             ShoppingCategoryImpl.class, shoppingCategory.getPrimaryKey(),
243             shoppingCategory);
244 
245         return shoppingCategory;
246     }
247 
248     protected ShoppingCategory toUnwrappedModel(
249         ShoppingCategory shoppingCategory) {
250         if (shoppingCategory instanceof ShoppingCategoryImpl) {
251             return shoppingCategory;
252         }
253 
254         ShoppingCategoryImpl shoppingCategoryImpl = new ShoppingCategoryImpl();
255 
256         shoppingCategoryImpl.setNew(shoppingCategory.isNew());
257         shoppingCategoryImpl.setPrimaryKey(shoppingCategory.getPrimaryKey());
258 
259         shoppingCategoryImpl.setCategoryId(shoppingCategory.getCategoryId());
260         shoppingCategoryImpl.setGroupId(shoppingCategory.getGroupId());
261         shoppingCategoryImpl.setCompanyId(shoppingCategory.getCompanyId());
262         shoppingCategoryImpl.setUserId(shoppingCategory.getUserId());
263         shoppingCategoryImpl.setUserName(shoppingCategory.getUserName());
264         shoppingCategoryImpl.setCreateDate(shoppingCategory.getCreateDate());
265         shoppingCategoryImpl.setModifiedDate(shoppingCategory.getModifiedDate());
266         shoppingCategoryImpl.setParentCategoryId(shoppingCategory.getParentCategoryId());
267         shoppingCategoryImpl.setName(shoppingCategory.getName());
268         shoppingCategoryImpl.setDescription(shoppingCategory.getDescription());
269 
270         return shoppingCategoryImpl;
271     }
272 
273     public ShoppingCategory findByPrimaryKey(Serializable primaryKey)
274         throws NoSuchModelException, SystemException {
275         return findByPrimaryKey(((Long)primaryKey).longValue());
276     }
277 
278     public ShoppingCategory findByPrimaryKey(long categoryId)
279         throws NoSuchCategoryException, SystemException {
280         ShoppingCategory shoppingCategory = fetchByPrimaryKey(categoryId);
281 
282         if (shoppingCategory == null) {
283             if (_log.isWarnEnabled()) {
284                 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + categoryId);
285             }
286 
287             throw new NoSuchCategoryException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
288                 categoryId);
289         }
290 
291         return shoppingCategory;
292     }
293 
294     public ShoppingCategory fetchByPrimaryKey(Serializable primaryKey)
295         throws SystemException {
296         return fetchByPrimaryKey(((Long)primaryKey).longValue());
297     }
298 
299     public ShoppingCategory fetchByPrimaryKey(long categoryId)
300         throws SystemException {
301         ShoppingCategory shoppingCategory = (ShoppingCategory)EntityCacheUtil.getResult(ShoppingCategoryModelImpl.ENTITY_CACHE_ENABLED,
302                 ShoppingCategoryImpl.class, categoryId, this);
303 
304         if (shoppingCategory == null) {
305             Session session = null;
306 
307             try {
308                 session = openSession();
309 
310                 shoppingCategory = (ShoppingCategory)session.get(ShoppingCategoryImpl.class,
311                         new Long(categoryId));
312             }
313             catch (Exception e) {
314                 throw processException(e);
315             }
316             finally {
317                 if (shoppingCategory != null) {
318                     cacheResult(shoppingCategory);
319                 }
320 
321                 closeSession(session);
322             }
323         }
324 
325         return shoppingCategory;
326     }
327 
328     public List<ShoppingCategory> findByGroupId(long groupId)
329         throws SystemException {
330         return findByGroupId(groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
331     }
332 
333     public List<ShoppingCategory> findByGroupId(long groupId, int start, int end)
334         throws SystemException {
335         return findByGroupId(groupId, start, end, null);
336     }
337 
338     public List<ShoppingCategory> findByGroupId(long groupId, int start,
339         int end, OrderByComparator orderByComparator) throws SystemException {
340         Object[] finderArgs = new Object[] {
341                 groupId,
342                 
343                 String.valueOf(start), String.valueOf(end),
344                 String.valueOf(orderByComparator)
345             };
346 
347         List<ShoppingCategory> list = (List<ShoppingCategory>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_GROUPID,
348                 finderArgs, this);
349 
350         if (list == null) {
351             StringBundler query = null;
352 
353             if (orderByComparator != null) {
354                 query = new StringBundler(3 +
355                         (orderByComparator.getOrderByFields().length * 3));
356             }
357             else {
358                 query = new StringBundler(3);
359             }
360 
361             query.append(_SQL_SELECT_SHOPPINGCATEGORY_WHERE);
362 
363             query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
364 
365             if (orderByComparator != null) {
366                 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
367                     orderByComparator);
368             }
369 
370             else {
371                 query.append(ShoppingCategoryModelImpl.ORDER_BY_JPQL);
372             }
373 
374             String sql = query.toString();
375 
376             Session session = null;
377 
378             try {
379                 session = openSession();
380 
381                 Query q = session.createQuery(sql);
382 
383                 QueryPos qPos = QueryPos.getInstance(q);
384 
385                 qPos.add(groupId);
386 
387                 list = (List<ShoppingCategory>)QueryUtil.list(q, getDialect(),
388                         start, end);
389             }
390             catch (Exception e) {
391                 throw processException(e);
392             }
393             finally {
394                 if (list == null) {
395                     list = new ArrayList<ShoppingCategory>();
396                 }
397 
398                 cacheResult(list);
399 
400                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_GROUPID,
401                     finderArgs, list);
402 
403                 closeSession(session);
404             }
405         }
406 
407         return list;
408     }
409 
410     public ShoppingCategory findByGroupId_First(long groupId,
411         OrderByComparator orderByComparator)
412         throws NoSuchCategoryException, SystemException {
413         List<ShoppingCategory> list = findByGroupId(groupId, 0, 1,
414                 orderByComparator);
415 
416         if (list.isEmpty()) {
417             StringBundler msg = new StringBundler(4);
418 
419             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
420 
421             msg.append("groupId=");
422             msg.append(groupId);
423 
424             msg.append(StringPool.CLOSE_CURLY_BRACE);
425 
426             throw new NoSuchCategoryException(msg.toString());
427         }
428         else {
429             return list.get(0);
430         }
431     }
432 
433     public ShoppingCategory findByGroupId_Last(long groupId,
434         OrderByComparator orderByComparator)
435         throws NoSuchCategoryException, SystemException {
436         int count = countByGroupId(groupId);
437 
438         List<ShoppingCategory> list = findByGroupId(groupId, count - 1, count,
439                 orderByComparator);
440 
441         if (list.isEmpty()) {
442             StringBundler msg = new StringBundler(4);
443 
444             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
445 
446             msg.append("groupId=");
447             msg.append(groupId);
448 
449             msg.append(StringPool.CLOSE_CURLY_BRACE);
450 
451             throw new NoSuchCategoryException(msg.toString());
452         }
453         else {
454             return list.get(0);
455         }
456     }
457 
458     public ShoppingCategory[] findByGroupId_PrevAndNext(long categoryId,
459         long groupId, OrderByComparator orderByComparator)
460         throws NoSuchCategoryException, SystemException {
461         ShoppingCategory shoppingCategory = findByPrimaryKey(categoryId);
462 
463         Session session = null;
464 
465         try {
466             session = openSession();
467 
468             ShoppingCategory[] array = new ShoppingCategoryImpl[3];
469 
470             array[0] = getByGroupId_PrevAndNext(session, shoppingCategory,
471                     groupId, orderByComparator, true);
472 
473             array[1] = shoppingCategory;
474 
475             array[2] = getByGroupId_PrevAndNext(session, shoppingCategory,
476                     groupId, orderByComparator, false);
477 
478             return array;
479         }
480         catch (Exception e) {
481             throw processException(e);
482         }
483         finally {
484             closeSession(session);
485         }
486     }
487 
488     protected ShoppingCategory getByGroupId_PrevAndNext(Session session,
489         ShoppingCategory shoppingCategory, long groupId,
490         OrderByComparator orderByComparator, boolean previous) {
491         StringBundler query = null;
492 
493         if (orderByComparator != null) {
494             query = new StringBundler(6 +
495                     (orderByComparator.getOrderByFields().length * 6));
496         }
497         else {
498             query = new StringBundler(3);
499         }
500 
501         query.append(_SQL_SELECT_SHOPPINGCATEGORY_WHERE);
502 
503         query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
504 
505         if (orderByComparator != null) {
506             String[] orderByFields = orderByComparator.getOrderByFields();
507 
508             if (orderByFields.length > 0) {
509                 query.append(WHERE_AND);
510             }
511 
512             for (int i = 0; i < orderByFields.length; i++) {
513                 query.append(_ORDER_BY_ENTITY_ALIAS);
514                 query.append(orderByFields[i]);
515 
516                 if ((i + 1) < orderByFields.length) {
517                     if (orderByComparator.isAscending() ^ previous) {
518                         query.append(WHERE_GREATER_THAN_HAS_NEXT);
519                     }
520                     else {
521                         query.append(WHERE_LESSER_THAN_HAS_NEXT);
522                     }
523                 }
524                 else {
525                     if (orderByComparator.isAscending() ^ previous) {
526                         query.append(WHERE_GREATER_THAN);
527                     }
528                     else {
529                         query.append(WHERE_LESSER_THAN);
530                     }
531                 }
532             }
533 
534             query.append(ORDER_BY_CLAUSE);
535 
536             for (int i = 0; i < orderByFields.length; i++) {
537                 query.append(_ORDER_BY_ENTITY_ALIAS);
538                 query.append(orderByFields[i]);
539 
540                 if ((i + 1) < orderByFields.length) {
541                     if (orderByComparator.isAscending() ^ previous) {
542                         query.append(ORDER_BY_ASC_HAS_NEXT);
543                     }
544                     else {
545                         query.append(ORDER_BY_DESC_HAS_NEXT);
546                     }
547                 }
548                 else {
549                     if (orderByComparator.isAscending() ^ previous) {
550                         query.append(ORDER_BY_ASC);
551                     }
552                     else {
553                         query.append(ORDER_BY_DESC);
554                     }
555                 }
556             }
557         }
558 
559         else {
560             query.append(ShoppingCategoryModelImpl.ORDER_BY_JPQL);
561         }
562 
563         String sql = query.toString();
564 
565         Query q = session.createQuery(sql);
566 
567         q.setFirstResult(0);
568         q.setMaxResults(2);
569 
570         QueryPos qPos = QueryPos.getInstance(q);
571 
572         qPos.add(groupId);
573 
574         if (orderByComparator != null) {
575             Object[] values = orderByComparator.getOrderByValues(shoppingCategory);
576 
577             for (Object value : values) {
578                 qPos.add(value);
579             }
580         }
581 
582         List<ShoppingCategory> list = q.list();
583 
584         if (list.size() == 2) {
585             return list.get(1);
586         }
587         else {
588             return null;
589         }
590     }
591 
592     public List<ShoppingCategory> findByG_P(long groupId, long parentCategoryId)
593         throws SystemException {
594         return findByG_P(groupId, parentCategoryId, QueryUtil.ALL_POS,
595             QueryUtil.ALL_POS, null);
596     }
597 
598     public List<ShoppingCategory> findByG_P(long groupId,
599         long parentCategoryId, int start, int end) throws SystemException {
600         return findByG_P(groupId, parentCategoryId, start, end, null);
601     }
602 
603     public List<ShoppingCategory> findByG_P(long groupId,
604         long parentCategoryId, int start, int end,
605         OrderByComparator orderByComparator) throws SystemException {
606         Object[] finderArgs = new Object[] {
607                 groupId, parentCategoryId,
608                 
609                 String.valueOf(start), String.valueOf(end),
610                 String.valueOf(orderByComparator)
611             };
612 
613         List<ShoppingCategory> list = (List<ShoppingCategory>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_P,
614                 finderArgs, this);
615 
616         if (list == null) {
617             StringBundler query = null;
618 
619             if (orderByComparator != null) {
620                 query = new StringBundler(4 +
621                         (orderByComparator.getOrderByFields().length * 3));
622             }
623             else {
624                 query = new StringBundler(4);
625             }
626 
627             query.append(_SQL_SELECT_SHOPPINGCATEGORY_WHERE);
628 
629             query.append(_FINDER_COLUMN_G_P_GROUPID_2);
630 
631             query.append(_FINDER_COLUMN_G_P_PARENTCATEGORYID_2);
632 
633             if (orderByComparator != null) {
634                 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
635                     orderByComparator);
636             }
637 
638             else {
639                 query.append(ShoppingCategoryModelImpl.ORDER_BY_JPQL);
640             }
641 
642             String sql = query.toString();
643 
644             Session session = null;
645 
646             try {
647                 session = openSession();
648 
649                 Query q = session.createQuery(sql);
650 
651                 QueryPos qPos = QueryPos.getInstance(q);
652 
653                 qPos.add(groupId);
654 
655                 qPos.add(parentCategoryId);
656 
657                 list = (List<ShoppingCategory>)QueryUtil.list(q, getDialect(),
658                         start, end);
659             }
660             catch (Exception e) {
661                 throw processException(e);
662             }
663             finally {
664                 if (list == null) {
665                     list = new ArrayList<ShoppingCategory>();
666                 }
667 
668                 cacheResult(list);
669 
670                 FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_P, finderArgs,
671                     list);
672 
673                 closeSession(session);
674             }
675         }
676 
677         return list;
678     }
679 
680     public ShoppingCategory findByG_P_First(long groupId,
681         long parentCategoryId, OrderByComparator orderByComparator)
682         throws NoSuchCategoryException, SystemException {
683         List<ShoppingCategory> list = findByG_P(groupId, parentCategoryId, 0,
684                 1, orderByComparator);
685 
686         if (list.isEmpty()) {
687             StringBundler msg = new StringBundler(6);
688 
689             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
690 
691             msg.append("groupId=");
692             msg.append(groupId);
693 
694             msg.append(", parentCategoryId=");
695             msg.append(parentCategoryId);
696 
697             msg.append(StringPool.CLOSE_CURLY_BRACE);
698 
699             throw new NoSuchCategoryException(msg.toString());
700         }
701         else {
702             return list.get(0);
703         }
704     }
705 
706     public ShoppingCategory findByG_P_Last(long groupId, long parentCategoryId,
707         OrderByComparator orderByComparator)
708         throws NoSuchCategoryException, SystemException {
709         int count = countByG_P(groupId, parentCategoryId);
710 
711         List<ShoppingCategory> list = findByG_P(groupId, parentCategoryId,
712                 count - 1, count, orderByComparator);
713 
714         if (list.isEmpty()) {
715             StringBundler msg = new StringBundler(6);
716 
717             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
718 
719             msg.append("groupId=");
720             msg.append(groupId);
721 
722             msg.append(", parentCategoryId=");
723             msg.append(parentCategoryId);
724 
725             msg.append(StringPool.CLOSE_CURLY_BRACE);
726 
727             throw new NoSuchCategoryException(msg.toString());
728         }
729         else {
730             return list.get(0);
731         }
732     }
733 
734     public ShoppingCategory[] findByG_P_PrevAndNext(long categoryId,
735         long groupId, long parentCategoryId, OrderByComparator orderByComparator)
736         throws NoSuchCategoryException, SystemException {
737         ShoppingCategory shoppingCategory = findByPrimaryKey(categoryId);
738 
739         Session session = null;
740 
741         try {
742             session = openSession();
743 
744             ShoppingCategory[] array = new ShoppingCategoryImpl[3];
745 
746             array[0] = getByG_P_PrevAndNext(session, shoppingCategory, groupId,
747                     parentCategoryId, orderByComparator, true);
748 
749             array[1] = shoppingCategory;
750 
751             array[2] = getByG_P_PrevAndNext(session, shoppingCategory, groupId,
752                     parentCategoryId, orderByComparator, false);
753 
754             return array;
755         }
756         catch (Exception e) {
757             throw processException(e);
758         }
759         finally {
760             closeSession(session);
761         }
762     }
763 
764     protected ShoppingCategory getByG_P_PrevAndNext(Session session,
765         ShoppingCategory shoppingCategory, long groupId, long parentCategoryId,
766         OrderByComparator orderByComparator, boolean previous) {
767         StringBundler query = null;
768 
769         if (orderByComparator != null) {
770             query = new StringBundler(6 +
771                     (orderByComparator.getOrderByFields().length * 6));
772         }
773         else {
774             query = new StringBundler(3);
775         }
776 
777         query.append(_SQL_SELECT_SHOPPINGCATEGORY_WHERE);
778 
779         query.append(_FINDER_COLUMN_G_P_GROUPID_2);
780 
781         query.append(_FINDER_COLUMN_G_P_PARENTCATEGORYID_2);
782 
783         if (orderByComparator != null) {
784             String[] orderByFields = orderByComparator.getOrderByFields();
785 
786             if (orderByFields.length > 0) {
787                 query.append(WHERE_AND);
788             }
789 
790             for (int i = 0; i < orderByFields.length; i++) {
791                 query.append(_ORDER_BY_ENTITY_ALIAS);
792                 query.append(orderByFields[i]);
793 
794                 if ((i + 1) < orderByFields.length) {
795                     if (orderByComparator.isAscending() ^ previous) {
796                         query.append(WHERE_GREATER_THAN_HAS_NEXT);
797                     }
798                     else {
799                         query.append(WHERE_LESSER_THAN_HAS_NEXT);
800                     }
801                 }
802                 else {
803                     if (orderByComparator.isAscending() ^ previous) {
804                         query.append(WHERE_GREATER_THAN);
805                     }
806                     else {
807                         query.append(WHERE_LESSER_THAN);
808                     }
809                 }
810             }
811 
812             query.append(ORDER_BY_CLAUSE);
813 
814             for (int i = 0; i < orderByFields.length; i++) {
815                 query.append(_ORDER_BY_ENTITY_ALIAS);
816                 query.append(orderByFields[i]);
817 
818                 if ((i + 1) < orderByFields.length) {
819                     if (orderByComparator.isAscending() ^ previous) {
820                         query.append(ORDER_BY_ASC_HAS_NEXT);
821                     }
822                     else {
823                         query.append(ORDER_BY_DESC_HAS_NEXT);
824                     }
825                 }
826                 else {
827                     if (orderByComparator.isAscending() ^ previous) {
828                         query.append(ORDER_BY_ASC);
829                     }
830                     else {
831                         query.append(ORDER_BY_DESC);
832                     }
833                 }
834             }
835         }
836 
837         else {
838             query.append(ShoppingCategoryModelImpl.ORDER_BY_JPQL);
839         }
840 
841         String sql = query.toString();
842 
843         Query q = session.createQuery(sql);
844 
845         q.setFirstResult(0);
846         q.setMaxResults(2);
847 
848         QueryPos qPos = QueryPos.getInstance(q);
849 
850         qPos.add(groupId);
851 
852         qPos.add(parentCategoryId);
853 
854         if (orderByComparator != null) {
855             Object[] values = orderByComparator.getOrderByValues(shoppingCategory);
856 
857             for (Object value : values) {
858                 qPos.add(value);
859             }
860         }
861 
862         List<ShoppingCategory> list = q.list();
863 
864         if (list.size() == 2) {
865             return list.get(1);
866         }
867         else {
868             return null;
869         }
870     }
871 
872     public List<ShoppingCategory> findAll() throws SystemException {
873         return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
874     }
875 
876     public List<ShoppingCategory> findAll(int start, int end)
877         throws SystemException {
878         return findAll(start, end, null);
879     }
880 
881     public List<ShoppingCategory> findAll(int start, int end,
882         OrderByComparator orderByComparator) throws SystemException {
883         Object[] finderArgs = new Object[] {
884                 String.valueOf(start), String.valueOf(end),
885                 String.valueOf(orderByComparator)
886             };
887 
888         List<ShoppingCategory> list = (List<ShoppingCategory>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
889                 finderArgs, this);
890 
891         if (list == null) {
892             StringBundler query = null;
893             String sql = null;
894 
895             if (orderByComparator != null) {
896                 query = new StringBundler(2 +
897                         (orderByComparator.getOrderByFields().length * 3));
898 
899                 query.append(_SQL_SELECT_SHOPPINGCATEGORY);
900 
901                 appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
902                     orderByComparator);
903 
904                 sql = query.toString();
905             }
906             else {
907                 sql = _SQL_SELECT_SHOPPINGCATEGORY.concat(ShoppingCategoryModelImpl.ORDER_BY_JPQL);
908             }
909 
910             Session session = null;
911 
912             try {
913                 session = openSession();
914 
915                 Query q = session.createQuery(sql);
916 
917                 if (orderByComparator == null) {
918                     list = (List<ShoppingCategory>)QueryUtil.list(q,
919                             getDialect(), start, end, false);
920 
921                     Collections.sort(list);
922                 }
923                 else {
924                     list = (List<ShoppingCategory>)QueryUtil.list(q,
925                             getDialect(), start, end);
926                 }
927             }
928             catch (Exception e) {
929                 throw processException(e);
930             }
931             finally {
932                 if (list == null) {
933                     list = new ArrayList<ShoppingCategory>();
934                 }
935 
936                 cacheResult(list);
937 
938                 FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
939 
940                 closeSession(session);
941             }
942         }
943 
944         return list;
945     }
946 
947     public void removeByGroupId(long groupId) throws SystemException {
948         for (ShoppingCategory shoppingCategory : findByGroupId(groupId)) {
949             remove(shoppingCategory);
950         }
951     }
952 
953     public void removeByG_P(long groupId, long parentCategoryId)
954         throws SystemException {
955         for (ShoppingCategory shoppingCategory : findByG_P(groupId,
956                 parentCategoryId)) {
957             remove(shoppingCategory);
958         }
959     }
960 
961     public void removeAll() throws SystemException {
962         for (ShoppingCategory shoppingCategory : findAll()) {
963             remove(shoppingCategory);
964         }
965     }
966 
967     public int countByGroupId(long groupId) throws SystemException {
968         Object[] finderArgs = new Object[] { groupId };
969 
970         Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_GROUPID,
971                 finderArgs, this);
972 
973         if (count == null) {
974             StringBundler query = new StringBundler(2);
975 
976             query.append(_SQL_COUNT_SHOPPINGCATEGORY_WHERE);
977 
978             query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
979 
980             String sql = query.toString();
981 
982             Session session = null;
983 
984             try {
985                 session = openSession();
986 
987                 Query q = session.createQuery(sql);
988 
989                 QueryPos qPos = QueryPos.getInstance(q);
990 
991                 qPos.add(groupId);
992 
993                 count = (Long)q.uniqueResult();
994             }
995             catch (Exception e) {
996                 throw processException(e);
997             }
998             finally {
999                 if (count == null) {
1000                    count = Long.valueOf(0);
1001                }
1002
1003                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_GROUPID,
1004                    finderArgs, count);
1005
1006                closeSession(session);
1007            }
1008        }
1009
1010        return count.intValue();
1011    }
1012
1013    public int countByG_P(long groupId, long parentCategoryId)
1014        throws SystemException {
1015        Object[] finderArgs = new Object[] { groupId, parentCategoryId };
1016
1017        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_P,
1018                finderArgs, this);
1019
1020        if (count == null) {
1021            StringBundler query = new StringBundler(3);
1022
1023            query.append(_SQL_COUNT_SHOPPINGCATEGORY_WHERE);
1024
1025            query.append(_FINDER_COLUMN_G_P_GROUPID_2);
1026
1027            query.append(_FINDER_COLUMN_G_P_PARENTCATEGORYID_2);
1028
1029            String sql = query.toString();
1030
1031            Session session = null;
1032
1033            try {
1034                session = openSession();
1035
1036                Query q = session.createQuery(sql);
1037
1038                QueryPos qPos = QueryPos.getInstance(q);
1039
1040                qPos.add(groupId);
1041
1042                qPos.add(parentCategoryId);
1043
1044                count = (Long)q.uniqueResult();
1045            }
1046            catch (Exception e) {
1047                throw processException(e);
1048            }
1049            finally {
1050                if (count == null) {
1051                    count = Long.valueOf(0);
1052                }
1053
1054                FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_P, finderArgs,
1055                    count);
1056
1057                closeSession(session);
1058            }
1059        }
1060
1061        return count.intValue();
1062    }
1063
1064    public int countAll() throws SystemException {
1065        Object[] finderArgs = new Object[0];
1066
1067        Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
1068                finderArgs, this);
1069
1070        if (count == null) {
1071            Session session = null;
1072
1073            try {
1074                session = openSession();
1075
1076                Query q = session.createQuery(_SQL_COUNT_SHOPPINGCATEGORY);
1077
1078                count = (Long)q.uniqueResult();
1079            }
1080            catch (Exception e) {
1081                throw processException(e);
1082            }
1083            finally {
1084                if (count == null) {
1085                    count = Long.valueOf(0);
1086                }
1087
1088                FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
1089                    count);
1090
1091                closeSession(session);
1092            }
1093        }
1094
1095        return count.intValue();
1096    }
1097
1098    public void afterPropertiesSet() {
1099        String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
1100                    com.liferay.portal.util.PropsUtil.get(
1101                        "value.object.listener.com.liferay.portlet.shopping.model.ShoppingCategory")));
1102
1103        if (listenerClassNames.length > 0) {
1104            try {
1105                List<ModelListener<ShoppingCategory>> listenersList = new ArrayList<ModelListener<ShoppingCategory>>();
1106
1107                for (String listenerClassName : listenerClassNames) {
1108                    listenersList.add((ModelListener<ShoppingCategory>)InstanceFactory.newInstance(
1109                            listenerClassName));
1110                }
1111
1112                listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
1113            }
1114            catch (Exception e) {
1115                _log.error(e);
1116            }
1117        }
1118    }
1119
1120    public void destroy() {
1121        EntityCacheUtil.removeCache(ShoppingCategoryImpl.class.getName());
1122        FinderCacheUtil.removeCache(FINDER_CLASS_NAME_ENTITY);
1123        FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST);
1124    }
1125
1126    @BeanReference(type = ShoppingCartPersistence.class)
1127    protected ShoppingCartPersistence shoppingCartPersistence;
1128    @BeanReference(type = ShoppingCategoryPersistence.class)
1129    protected ShoppingCategoryPersistence shoppingCategoryPersistence;
1130    @BeanReference(type = ShoppingCouponPersistence.class)
1131    protected ShoppingCouponPersistence shoppingCouponPersistence;
1132    @BeanReference(type = ShoppingItemPersistence.class)
1133    protected ShoppingItemPersistence shoppingItemPersistence;
1134    @BeanReference(type = ShoppingItemFieldPersistence.class)
1135    protected ShoppingItemFieldPersistence shoppingItemFieldPersistence;
1136    @BeanReference(type = ShoppingItemPricePersistence.class)
1137    protected ShoppingItemPricePersistence shoppingItemPricePersistence;
1138    @BeanReference(type = ShoppingOrderPersistence.class)
1139    protected ShoppingOrderPersistence shoppingOrderPersistence;
1140    @BeanReference(type = ShoppingOrderItemPersistence.class)
1141    protected ShoppingOrderItemPersistence shoppingOrderItemPersistence;
1142    @BeanReference(type = ResourcePersistence.class)
1143    protected ResourcePersistence resourcePersistence;
1144    @BeanReference(type = UserPersistence.class)
1145    protected UserPersistence userPersistence;
1146    private static final String _SQL_SELECT_SHOPPINGCATEGORY = "SELECT shoppingCategory FROM ShoppingCategory shoppingCategory";
1147    private static final String _SQL_SELECT_SHOPPINGCATEGORY_WHERE = "SELECT shoppingCategory FROM ShoppingCategory shoppingCategory WHERE ";
1148    private static final String _SQL_COUNT_SHOPPINGCATEGORY = "SELECT COUNT(shoppingCategory) FROM ShoppingCategory shoppingCategory";
1149    private static final String _SQL_COUNT_SHOPPINGCATEGORY_WHERE = "SELECT COUNT(shoppingCategory) FROM ShoppingCategory shoppingCategory WHERE ";
1150    private static final String _FINDER_COLUMN_GROUPID_GROUPID_2 = "shoppingCategory.groupId = ?";
1151    private static final String _FINDER_COLUMN_G_P_GROUPID_2 = "shoppingCategory.groupId = ? AND ";
1152    private static final String _FINDER_COLUMN_G_P_PARENTCATEGORYID_2 = "shoppingCategory.parentCategoryId = ?";
1153    private static final String _ORDER_BY_ENTITY_ALIAS = "shoppingCategory.";
1154    private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No ShoppingCategory exists with the primary key ";
1155    private static final String _NO_SUCH_ENTITY_WITH_KEY = "No ShoppingCategory exists with the key {";
1156    private static Log _log = LogFactoryUtil.getLog(ShoppingCategoryPersistenceImpl.class);
1157}