1   /**
2    * Copyright (c) 2000-2008 Liferay, Inc. All rights reserved.
3    *
4    * Permission is hereby granted, free of charge, to any person obtaining a copy
5    * of this software and associated documentation files (the "Software"), to deal
6    * in the Software without restriction, including without limitation the rights
7    * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
8    * copies of the Software, and to permit persons to whom the Software is
9    * furnished to do so, subject to the following conditions:
10   *
11   * The above copyright notice and this permission notice shall be included in
12   * all copies or substantial portions of the Software.
13   *
14   * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
15   * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
16   * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
17   * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
18   * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
19   * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
20   * SOFTWARE.
21   */
22  
23  package com.liferay.portal.service.persistence;
24  
25  import com.liferay.portal.NoSuchPasswordPolicyException;
26  import com.liferay.portal.SystemException;
27  import com.liferay.portal.kernel.dao.DynamicQuery;
28  import com.liferay.portal.kernel.dao.DynamicQueryInitializer;
29  import com.liferay.portal.kernel.util.GetterUtil;
30  import com.liferay.portal.kernel.util.OrderByComparator;
31  import com.liferay.portal.kernel.util.StringMaker;
32  import com.liferay.portal.kernel.util.StringPool;
33  import com.liferay.portal.kernel.util.Validator;
34  import com.liferay.portal.model.ModelListener;
35  import com.liferay.portal.model.PasswordPolicy;
36  import com.liferay.portal.model.impl.PasswordPolicyImpl;
37  import com.liferay.portal.model.impl.PasswordPolicyModelImpl;
38  import com.liferay.portal.spring.hibernate.FinderCache;
39  import com.liferay.portal.spring.hibernate.HibernateUtil;
40  import com.liferay.portal.util.PropsUtil;
41  
42  import com.liferay.util.dao.hibernate.QueryUtil;
43  
44  import org.apache.commons.logging.Log;
45  import org.apache.commons.logging.LogFactory;
46  
47  import org.hibernate.Query;
48  import org.hibernate.Session;
49  
50  import java.util.Collections;
51  import java.util.Iterator;
52  import java.util.List;
53  
54  /**
55   * <a href="PasswordPolicyPersistenceImpl.java.html"><b><i>View Source</i></b></a>
56   *
57   * @author Brian Wing Shun Chan
58   *
59   */
60  public class PasswordPolicyPersistenceImpl extends BasePersistence
61      implements PasswordPolicyPersistence {
62      public PasswordPolicy create(long passwordPolicyId) {
63          PasswordPolicy passwordPolicy = new PasswordPolicyImpl();
64  
65          passwordPolicy.setNew(true);
66          passwordPolicy.setPrimaryKey(passwordPolicyId);
67  
68          return passwordPolicy;
69      }
70  
71      public PasswordPolicy remove(long passwordPolicyId)
72          throws NoSuchPasswordPolicyException, SystemException {
73          Session session = null;
74  
75          try {
76              session = openSession();
77  
78              PasswordPolicy passwordPolicy = (PasswordPolicy)session.get(PasswordPolicyImpl.class,
79                      new Long(passwordPolicyId));
80  
81              if (passwordPolicy == null) {
82                  if (_log.isWarnEnabled()) {
83                      _log.warn("No PasswordPolicy exists with the primary key " +
84                          passwordPolicyId);
85                  }
86  
87                  throw new NoSuchPasswordPolicyException(
88                      "No PasswordPolicy exists with the primary key " +
89                      passwordPolicyId);
90              }
91  
92              return remove(passwordPolicy);
93          }
94          catch (NoSuchPasswordPolicyException nsee) {
95              throw nsee;
96          }
97          catch (Exception e) {
98              throw HibernateUtil.processException(e);
99          }
100         finally {
101             closeSession(session);
102         }
103     }
104 
105     public PasswordPolicy remove(PasswordPolicy passwordPolicy)
106         throws SystemException {
107         ModelListener listener = _getListener();
108 
109         if (listener != null) {
110             listener.onBeforeRemove(passwordPolicy);
111         }
112 
113         passwordPolicy = removeImpl(passwordPolicy);
114 
115         if (listener != null) {
116             listener.onAfterRemove(passwordPolicy);
117         }
118 
119         return passwordPolicy;
120     }
121 
122     protected PasswordPolicy removeImpl(PasswordPolicy passwordPolicy)
123         throws SystemException {
124         Session session = null;
125 
126         try {
127             session = openSession();
128 
129             session.delete(passwordPolicy);
130 
131             session.flush();
132 
133             return passwordPolicy;
134         }
135         catch (Exception e) {
136             throw HibernateUtil.processException(e);
137         }
138         finally {
139             closeSession(session);
140 
141             FinderCache.clearCache(PasswordPolicy.class.getName());
142         }
143     }
144 
145     public PasswordPolicy update(PasswordPolicy passwordPolicy)
146         throws SystemException {
147         return update(passwordPolicy, false);
148     }
149 
150     public PasswordPolicy update(PasswordPolicy passwordPolicy, boolean merge)
151         throws SystemException {
152         ModelListener listener = _getListener();
153 
154         boolean isNew = passwordPolicy.isNew();
155 
156         if (listener != null) {
157             if (isNew) {
158                 listener.onBeforeCreate(passwordPolicy);
159             }
160             else {
161                 listener.onBeforeUpdate(passwordPolicy);
162             }
163         }
164 
165         passwordPolicy = updateImpl(passwordPolicy, merge);
166 
167         if (listener != null) {
168             if (isNew) {
169                 listener.onAfterCreate(passwordPolicy);
170             }
171             else {
172                 listener.onAfterUpdate(passwordPolicy);
173             }
174         }
175 
176         return passwordPolicy;
177     }
178 
179     public PasswordPolicy updateImpl(
180         com.liferay.portal.model.PasswordPolicy passwordPolicy, boolean merge)
181         throws SystemException {
182         Session session = null;
183 
184         try {
185             session = openSession();
186 
187             if (merge) {
188                 session.merge(passwordPolicy);
189             }
190             else {
191                 if (passwordPolicy.isNew()) {
192                     session.save(passwordPolicy);
193                 }
194             }
195 
196             session.flush();
197 
198             passwordPolicy.setNew(false);
199 
200             return passwordPolicy;
201         }
202         catch (Exception e) {
203             throw HibernateUtil.processException(e);
204         }
205         finally {
206             closeSession(session);
207 
208             FinderCache.clearCache(PasswordPolicy.class.getName());
209         }
210     }
211 
212     public PasswordPolicy findByPrimaryKey(long passwordPolicyId)
213         throws NoSuchPasswordPolicyException, SystemException {
214         PasswordPolicy passwordPolicy = fetchByPrimaryKey(passwordPolicyId);
215 
216         if (passwordPolicy == null) {
217             if (_log.isWarnEnabled()) {
218                 _log.warn("No PasswordPolicy exists with the primary key " +
219                     passwordPolicyId);
220             }
221 
222             throw new NoSuchPasswordPolicyException(
223                 "No PasswordPolicy exists with the primary key " +
224                 passwordPolicyId);
225         }
226 
227         return passwordPolicy;
228     }
229 
230     public PasswordPolicy fetchByPrimaryKey(long passwordPolicyId)
231         throws SystemException {
232         Session session = null;
233 
234         try {
235             session = openSession();
236 
237             return (PasswordPolicy)session.get(PasswordPolicyImpl.class,
238                 new Long(passwordPolicyId));
239         }
240         catch (Exception e) {
241             throw HibernateUtil.processException(e);
242         }
243         finally {
244             closeSession(session);
245         }
246     }
247 
248     public PasswordPolicy findByC_DP(long companyId, boolean defaultPolicy)
249         throws NoSuchPasswordPolicyException, SystemException {
250         PasswordPolicy passwordPolicy = fetchByC_DP(companyId, defaultPolicy);
251 
252         if (passwordPolicy == null) {
253             StringMaker msg = new StringMaker();
254 
255             msg.append("No PasswordPolicy exists with the key {");
256 
257             msg.append("companyId=" + companyId);
258 
259             msg.append(", ");
260             msg.append("defaultPolicy=" + defaultPolicy);
261 
262             msg.append(StringPool.CLOSE_CURLY_BRACE);
263 
264             if (_log.isWarnEnabled()) {
265                 _log.warn(msg.toString());
266             }
267 
268             throw new NoSuchPasswordPolicyException(msg.toString());
269         }
270 
271         return passwordPolicy;
272     }
273 
274     public PasswordPolicy fetchByC_DP(long companyId, boolean defaultPolicy)
275         throws SystemException {
276         boolean finderClassNameCacheEnabled = PasswordPolicyModelImpl.CACHE_ENABLED;
277         String finderClassName = PasswordPolicy.class.getName();
278         String finderMethodName = "fetchByC_DP";
279         String[] finderParams = new String[] {
280                 Long.class.getName(), Boolean.class.getName()
281             };
282         Object[] finderArgs = new Object[] {
283                 new Long(companyId), Boolean.valueOf(defaultPolicy)
284             };
285 
286         Object result = null;
287 
288         if (finderClassNameCacheEnabled) {
289             result = FinderCache.getResult(finderClassName, finderMethodName,
290                     finderParams, finderArgs, getSessionFactory());
291         }
292 
293         if (result == null) {
294             Session session = null;
295 
296             try {
297                 session = openSession();
298 
299                 StringMaker query = new StringMaker();
300 
301                 query.append(
302                     "FROM com.liferay.portal.model.PasswordPolicy WHERE ");
303 
304                 query.append("companyId = ?");
305 
306                 query.append(" AND ");
307 
308                 query.append("defaultPolicy = ?");
309 
310                 query.append(" ");
311 
312                 Query q = session.createQuery(query.toString());
313 
314                 int queryPos = 0;
315 
316                 q.setLong(queryPos++, companyId);
317 
318                 q.setBoolean(queryPos++, defaultPolicy);
319 
320                 List list = q.list();
321 
322                 FinderCache.putResult(finderClassNameCacheEnabled,
323                     finderClassName, finderMethodName, finderParams,
324                     finderArgs, list);
325 
326                 if (list.size() == 0) {
327                     return null;
328                 }
329                 else {
330                     return (PasswordPolicy)list.get(0);
331                 }
332             }
333             catch (Exception e) {
334                 throw HibernateUtil.processException(e);
335             }
336             finally {
337                 closeSession(session);
338             }
339         }
340         else {
341             List list = (List)result;
342 
343             if (list.size() == 0) {
344                 return null;
345             }
346             else {
347                 return (PasswordPolicy)list.get(0);
348             }
349         }
350     }
351 
352     public PasswordPolicy findByC_N(long companyId, String name)
353         throws NoSuchPasswordPolicyException, SystemException {
354         PasswordPolicy passwordPolicy = fetchByC_N(companyId, name);
355 
356         if (passwordPolicy == null) {
357             StringMaker msg = new StringMaker();
358 
359             msg.append("No PasswordPolicy exists with the key {");
360 
361             msg.append("companyId=" + companyId);
362 
363             msg.append(", ");
364             msg.append("name=" + name);
365 
366             msg.append(StringPool.CLOSE_CURLY_BRACE);
367 
368             if (_log.isWarnEnabled()) {
369                 _log.warn(msg.toString());
370             }
371 
372             throw new NoSuchPasswordPolicyException(msg.toString());
373         }
374 
375         return passwordPolicy;
376     }
377 
378     public PasswordPolicy fetchByC_N(long companyId, String name)
379         throws SystemException {
380         boolean finderClassNameCacheEnabled = PasswordPolicyModelImpl.CACHE_ENABLED;
381         String finderClassName = PasswordPolicy.class.getName();
382         String finderMethodName = "fetchByC_N";
383         String[] finderParams = new String[] {
384                 Long.class.getName(), String.class.getName()
385             };
386         Object[] finderArgs = new Object[] { new Long(companyId), name };
387 
388         Object result = null;
389 
390         if (finderClassNameCacheEnabled) {
391             result = FinderCache.getResult(finderClassName, finderMethodName,
392                     finderParams, finderArgs, getSessionFactory());
393         }
394 
395         if (result == null) {
396             Session session = null;
397 
398             try {
399                 session = openSession();
400 
401                 StringMaker query = new StringMaker();
402 
403                 query.append(
404                     "FROM com.liferay.portal.model.PasswordPolicy WHERE ");
405 
406                 query.append("companyId = ?");
407 
408                 query.append(" AND ");
409 
410                 if (name == null) {
411                     query.append("name IS NULL");
412                 }
413                 else {
414                     query.append("name = ?");
415                 }
416 
417                 query.append(" ");
418 
419                 Query q = session.createQuery(query.toString());
420 
421                 int queryPos = 0;
422 
423                 q.setLong(queryPos++, companyId);
424 
425                 if (name != null) {
426                     q.setString(queryPos++, name);
427                 }
428 
429                 List list = q.list();
430 
431                 FinderCache.putResult(finderClassNameCacheEnabled,
432                     finderClassName, finderMethodName, finderParams,
433                     finderArgs, list);
434 
435                 if (list.size() == 0) {
436                     return null;
437                 }
438                 else {
439                     return (PasswordPolicy)list.get(0);
440                 }
441             }
442             catch (Exception e) {
443                 throw HibernateUtil.processException(e);
444             }
445             finally {
446                 closeSession(session);
447             }
448         }
449         else {
450             List list = (List)result;
451 
452             if (list.size() == 0) {
453                 return null;
454             }
455             else {
456                 return (PasswordPolicy)list.get(0);
457             }
458         }
459     }
460 
461     public List findWithDynamicQuery(DynamicQueryInitializer queryInitializer)
462         throws SystemException {
463         Session session = null;
464 
465         try {
466             session = openSession();
467 
468             DynamicQuery query = queryInitializer.initialize(session);
469 
470             return query.list();
471         }
472         catch (Exception e) {
473             throw HibernateUtil.processException(e);
474         }
475         finally {
476             closeSession(session);
477         }
478     }
479 
480     public List findWithDynamicQuery(DynamicQueryInitializer queryInitializer,
481         int begin, int end) throws SystemException {
482         Session session = null;
483 
484         try {
485             session = openSession();
486 
487             DynamicQuery query = queryInitializer.initialize(session);
488 
489             query.setLimit(begin, end);
490 
491             return query.list();
492         }
493         catch (Exception e) {
494             throw HibernateUtil.processException(e);
495         }
496         finally {
497             closeSession(session);
498         }
499     }
500 
501     public List findAll() throws SystemException {
502         return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
503     }
504 
505     public List findAll(int begin, int end) throws SystemException {
506         return findAll(begin, end, null);
507     }
508 
509     public List findAll(int begin, int end, OrderByComparator obc)
510         throws SystemException {
511         boolean finderClassNameCacheEnabled = PasswordPolicyModelImpl.CACHE_ENABLED;
512         String finderClassName = PasswordPolicy.class.getName();
513         String finderMethodName = "findAll";
514         String[] finderParams = new String[] {
515                 "java.lang.Integer", "java.lang.Integer",
516                 "com.liferay.portal.kernel.util.OrderByComparator"
517             };
518         Object[] finderArgs = new Object[] {
519                 String.valueOf(begin), String.valueOf(end), String.valueOf(obc)
520             };
521 
522         Object result = null;
523 
524         if (finderClassNameCacheEnabled) {
525             result = FinderCache.getResult(finderClassName, finderMethodName,
526                     finderParams, finderArgs, getSessionFactory());
527         }
528 
529         if (result == null) {
530             Session session = null;
531 
532             try {
533                 session = openSession();
534 
535                 StringMaker query = new StringMaker();
536 
537                 query.append("FROM com.liferay.portal.model.PasswordPolicy ");
538 
539                 if (obc != null) {
540                     query.append("ORDER BY ");
541                     query.append(obc.getOrderBy());
542                 }
543 
544                 Query q = session.createQuery(query.toString());
545 
546                 List list = QueryUtil.list(q, getDialect(), begin, end);
547 
548                 if (obc == null) {
549                     Collections.sort(list);
550                 }
551 
552                 FinderCache.putResult(finderClassNameCacheEnabled,
553                     finderClassName, finderMethodName, finderParams,
554                     finderArgs, list);
555 
556                 return list;
557             }
558             catch (Exception e) {
559                 throw HibernateUtil.processException(e);
560             }
561             finally {
562                 closeSession(session);
563             }
564         }
565         else {
566             return (List)result;
567         }
568     }
569 
570     public void removeByC_DP(long companyId, boolean defaultPolicy)
571         throws NoSuchPasswordPolicyException, SystemException {
572         PasswordPolicy passwordPolicy = findByC_DP(companyId, defaultPolicy);
573 
574         remove(passwordPolicy);
575     }
576 
577     public void removeByC_N(long companyId, String name)
578         throws NoSuchPasswordPolicyException, SystemException {
579         PasswordPolicy passwordPolicy = findByC_N(companyId, name);
580 
581         remove(passwordPolicy);
582     }
583 
584     public void removeAll() throws SystemException {
585         Iterator itr = findAll().iterator();
586 
587         while (itr.hasNext()) {
588             remove((PasswordPolicy)itr.next());
589         }
590     }
591 
592     public int countByC_DP(long companyId, boolean defaultPolicy)
593         throws SystemException {
594         boolean finderClassNameCacheEnabled = PasswordPolicyModelImpl.CACHE_ENABLED;
595         String finderClassName = PasswordPolicy.class.getName();
596         String finderMethodName = "countByC_DP";
597         String[] finderParams = new String[] {
598                 Long.class.getName(), Boolean.class.getName()
599             };
600         Object[] finderArgs = new Object[] {
601                 new Long(companyId), Boolean.valueOf(defaultPolicy)
602             };
603 
604         Object result = null;
605 
606         if (finderClassNameCacheEnabled) {
607             result = FinderCache.getResult(finderClassName, finderMethodName,
608                     finderParams, finderArgs, getSessionFactory());
609         }
610 
611         if (result == null) {
612             Session session = null;
613 
614             try {
615                 session = openSession();
616 
617                 StringMaker query = new StringMaker();
618 
619                 query.append("SELECT COUNT(*) ");
620                 query.append(
621                     "FROM com.liferay.portal.model.PasswordPolicy WHERE ");
622 
623                 query.append("companyId = ?");
624 
625                 query.append(" AND ");
626 
627                 query.append("defaultPolicy = ?");
628 
629                 query.append(" ");
630 
631                 Query q = session.createQuery(query.toString());
632 
633                 int queryPos = 0;
634 
635                 q.setLong(queryPos++, companyId);
636 
637                 q.setBoolean(queryPos++, defaultPolicy);
638 
639                 Long count = null;
640 
641                 Iterator itr = q.list().iterator();
642 
643                 if (itr.hasNext()) {
644                     count = (Long)itr.next();
645                 }
646 
647                 if (count == null) {
648                     count = new Long(0);
649                 }
650 
651                 FinderCache.putResult(finderClassNameCacheEnabled,
652                     finderClassName, finderMethodName, finderParams,
653                     finderArgs, count);
654 
655                 return count.intValue();
656             }
657             catch (Exception e) {
658                 throw HibernateUtil.processException(e);
659             }
660             finally {
661                 closeSession(session);
662             }
663         }
664         else {
665             return ((Long)result).intValue();
666         }
667     }
668 
669     public int countByC_N(long companyId, String name)
670         throws SystemException {
671         boolean finderClassNameCacheEnabled = PasswordPolicyModelImpl.CACHE_ENABLED;
672         String finderClassName = PasswordPolicy.class.getName();
673         String finderMethodName = "countByC_N";
674         String[] finderParams = new String[] {
675                 Long.class.getName(), String.class.getName()
676             };
677         Object[] finderArgs = new Object[] { new Long(companyId), name };
678 
679         Object result = null;
680 
681         if (finderClassNameCacheEnabled) {
682             result = FinderCache.getResult(finderClassName, finderMethodName,
683                     finderParams, finderArgs, getSessionFactory());
684         }
685 
686         if (result == null) {
687             Session session = null;
688 
689             try {
690                 session = openSession();
691 
692                 StringMaker query = new StringMaker();
693 
694                 query.append("SELECT COUNT(*) ");
695                 query.append(
696                     "FROM com.liferay.portal.model.PasswordPolicy WHERE ");
697 
698                 query.append("companyId = ?");
699 
700                 query.append(" AND ");
701 
702                 if (name == null) {
703                     query.append("name IS NULL");
704                 }
705                 else {
706                     query.append("name = ?");
707                 }
708 
709                 query.append(" ");
710 
711                 Query q = session.createQuery(query.toString());
712 
713                 int queryPos = 0;
714 
715                 q.setLong(queryPos++, companyId);
716 
717                 if (name != null) {
718                     q.setString(queryPos++, name);
719                 }
720 
721                 Long count = null;
722 
723                 Iterator itr = q.list().iterator();
724 
725                 if (itr.hasNext()) {
726                     count = (Long)itr.next();
727                 }
728 
729                 if (count == null) {
730                     count = new Long(0);
731                 }
732 
733                 FinderCache.putResult(finderClassNameCacheEnabled,
734                     finderClassName, finderMethodName, finderParams,
735                     finderArgs, count);
736 
737                 return count.intValue();
738             }
739             catch (Exception e) {
740                 throw HibernateUtil.processException(e);
741             }
742             finally {
743                 closeSession(session);
744             }
745         }
746         else {
747             return ((Long)result).intValue();
748         }
749     }
750 
751     public int countAll() throws SystemException {
752         boolean finderClassNameCacheEnabled = PasswordPolicyModelImpl.CACHE_ENABLED;
753         String finderClassName = PasswordPolicy.class.getName();
754         String finderMethodName = "countAll";
755         String[] finderParams = new String[] {  };
756         Object[] finderArgs = new Object[] {  };
757 
758         Object result = null;
759 
760         if (finderClassNameCacheEnabled) {
761             result = FinderCache.getResult(finderClassName, finderMethodName,
762                     finderParams, finderArgs, getSessionFactory());
763         }
764 
765         if (result == null) {
766             Session session = null;
767 
768             try {
769                 session = openSession();
770 
771                 Query q = session.createQuery(
772                         "SELECT COUNT(*) FROM com.liferay.portal.model.PasswordPolicy");
773 
774                 Long count = null;
775 
776                 Iterator itr = q.list().iterator();
777 
778                 if (itr.hasNext()) {
779                     count = (Long)itr.next();
780                 }
781 
782                 if (count == null) {
783                     count = new Long(0);
784                 }
785 
786                 FinderCache.putResult(finderClassNameCacheEnabled,
787                     finderClassName, finderMethodName, finderParams,
788                     finderArgs, count);
789 
790                 return count.intValue();
791             }
792             catch (Exception e) {
793                 throw HibernateUtil.processException(e);
794             }
795             finally {
796                 closeSession(session);
797             }
798         }
799         else {
800             return ((Long)result).intValue();
801         }
802     }
803 
804     protected void initDao() {
805     }
806 
807     private static ModelListener _getListener() {
808         if (Validator.isNotNull(_LISTENER)) {
809             try {
810                 return (ModelListener)Class.forName(_LISTENER).newInstance();
811             }
812             catch (Exception e) {
813                 _log.error(e);
814             }
815         }
816 
817         return null;
818     }
819 
820     private static final String _LISTENER = GetterUtil.getString(PropsUtil.get(
821                 "value.object.listener.com.liferay.portal.model.PasswordPolicy"));
822     private static Log _log = LogFactory.getLog(PasswordPolicyPersistenceImpl.class);
823 }