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.StringUtil;
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.ArrayList;
51  import java.util.Collections;
52  import java.util.Iterator;
53  import java.util.List;
54  
55  /**
56   * <a href="PasswordPolicyPersistenceImpl.java.html"><b><i>View Source</i></b></a>
57   *
58   * @author Brian Wing Shun Chan
59   *
60   */
61  public class PasswordPolicyPersistenceImpl extends BasePersistence
62      implements PasswordPolicyPersistence {
63      public PasswordPolicy create(long passwordPolicyId) {
64          PasswordPolicy passwordPolicy = new PasswordPolicyImpl();
65  
66          passwordPolicy.setNew(true);
67          passwordPolicy.setPrimaryKey(passwordPolicyId);
68  
69          return passwordPolicy;
70      }
71  
72      public PasswordPolicy remove(long passwordPolicyId)
73          throws NoSuchPasswordPolicyException, SystemException {
74          Session session = null;
75  
76          try {
77              session = openSession();
78  
79              PasswordPolicy passwordPolicy = (PasswordPolicy)session.get(PasswordPolicyImpl.class,
80                      new Long(passwordPolicyId));
81  
82              if (passwordPolicy == null) {
83                  if (_log.isWarnEnabled()) {
84                      _log.warn("No PasswordPolicy exists with the primary key " +
85                          passwordPolicyId);
86                  }
87  
88                  throw new NoSuchPasswordPolicyException(
89                      "No PasswordPolicy exists with the primary key " +
90                      passwordPolicyId);
91              }
92  
93              return remove(passwordPolicy);
94          }
95          catch (NoSuchPasswordPolicyException nsee) {
96              throw nsee;
97          }
98          catch (Exception e) {
99              throw HibernateUtil.processException(e);
100         }
101         finally {
102             closeSession(session);
103         }
104     }
105 
106     public PasswordPolicy remove(PasswordPolicy passwordPolicy)
107         throws SystemException {
108         if (_listeners != null) {
109             for (ModelListener listener : _listeners) {
110                 listener.onBeforeRemove(passwordPolicy);
111             }
112         }
113 
114         passwordPolicy = removeImpl(passwordPolicy);
115 
116         if (_listeners != null) {
117             for (ModelListener listener : _listeners) {
118                 listener.onAfterRemove(passwordPolicy);
119             }
120         }
121 
122         return passwordPolicy;
123     }
124 
125     protected PasswordPolicy removeImpl(PasswordPolicy passwordPolicy)
126         throws SystemException {
127         Session session = null;
128 
129         try {
130             session = openSession();
131 
132             session.delete(passwordPolicy);
133 
134             session.flush();
135 
136             return passwordPolicy;
137         }
138         catch (Exception e) {
139             throw HibernateUtil.processException(e);
140         }
141         finally {
142             closeSession(session);
143 
144             FinderCache.clearCache(PasswordPolicy.class.getName());
145         }
146     }
147 
148     /**
149      * @deprecated Use <code>update(PasswordPolicy passwordPolicy, boolean merge)</code>.
150      */
151     public PasswordPolicy update(PasswordPolicy passwordPolicy)
152         throws SystemException {
153         if (_log.isWarnEnabled()) {
154             _log.warn(
155                 "Using the deprecated update(PasswordPolicy passwordPolicy) method. Use update(PasswordPolicy passwordPolicy, boolean merge) instead.");
156         }
157 
158         return update(passwordPolicy, false);
159     }
160 
161     /**
162      * Add, update, or merge, the entity. This method also calls the model
163      * listeners to trigger the proper events associated with adding, deleting,
164      * or updating an entity.
165      *
166      * @param        passwordPolicy the entity to add, update, or merge
167      * @param        merge boolean value for whether to merge the entity. The
168      *                default value is false. Setting merge to true is more
169      *                expensive and should only be true when passwordPolicy is
170      *                transient. See LEP-5473 for a detailed discussion of this
171      *                method.
172      * @return        true if the portlet can be displayed via Ajax
173      */
174     public PasswordPolicy update(PasswordPolicy passwordPolicy, boolean merge)
175         throws SystemException {
176         boolean isNew = passwordPolicy.isNew();
177 
178         if (_listeners != null) {
179             for (ModelListener listener : _listeners) {
180                 if (isNew) {
181                     listener.onBeforeCreate(passwordPolicy);
182                 }
183                 else {
184                     listener.onBeforeUpdate(passwordPolicy);
185                 }
186             }
187         }
188 
189         passwordPolicy = updateImpl(passwordPolicy, merge);
190 
191         if (_listeners != null) {
192             for (ModelListener listener : _listeners) {
193                 if (isNew) {
194                     listener.onAfterCreate(passwordPolicy);
195                 }
196                 else {
197                     listener.onAfterUpdate(passwordPolicy);
198                 }
199             }
200         }
201 
202         return passwordPolicy;
203     }
204 
205     public PasswordPolicy updateImpl(
206         com.liferay.portal.model.PasswordPolicy passwordPolicy, boolean merge)
207         throws SystemException {
208         Session session = null;
209 
210         try {
211             session = openSession();
212 
213             if (merge) {
214                 session.merge(passwordPolicy);
215             }
216             else {
217                 if (passwordPolicy.isNew()) {
218                     session.save(passwordPolicy);
219                 }
220             }
221 
222             session.flush();
223 
224             passwordPolicy.setNew(false);
225 
226             return passwordPolicy;
227         }
228         catch (Exception e) {
229             throw HibernateUtil.processException(e);
230         }
231         finally {
232             closeSession(session);
233 
234             FinderCache.clearCache(PasswordPolicy.class.getName());
235         }
236     }
237 
238     public PasswordPolicy findByPrimaryKey(long passwordPolicyId)
239         throws NoSuchPasswordPolicyException, SystemException {
240         PasswordPolicy passwordPolicy = fetchByPrimaryKey(passwordPolicyId);
241 
242         if (passwordPolicy == null) {
243             if (_log.isWarnEnabled()) {
244                 _log.warn("No PasswordPolicy exists with the primary key " +
245                     passwordPolicyId);
246             }
247 
248             throw new NoSuchPasswordPolicyException(
249                 "No PasswordPolicy exists with the primary key " +
250                 passwordPolicyId);
251         }
252 
253         return passwordPolicy;
254     }
255 
256     public PasswordPolicy fetchByPrimaryKey(long passwordPolicyId)
257         throws SystemException {
258         Session session = null;
259 
260         try {
261             session = openSession();
262 
263             return (PasswordPolicy)session.get(PasswordPolicyImpl.class,
264                 new Long(passwordPolicyId));
265         }
266         catch (Exception e) {
267             throw HibernateUtil.processException(e);
268         }
269         finally {
270             closeSession(session);
271         }
272     }
273 
274     public PasswordPolicy findByC_DP(long companyId, boolean defaultPolicy)
275         throws NoSuchPasswordPolicyException, SystemException {
276         PasswordPolicy passwordPolicy = fetchByC_DP(companyId, defaultPolicy);
277 
278         if (passwordPolicy == null) {
279             StringMaker msg = new StringMaker();
280 
281             msg.append("No PasswordPolicy exists with the key {");
282 
283             msg.append("companyId=" + companyId);
284 
285             msg.append(", ");
286             msg.append("defaultPolicy=" + defaultPolicy);
287 
288             msg.append(StringPool.CLOSE_CURLY_BRACE);
289 
290             if (_log.isWarnEnabled()) {
291                 _log.warn(msg.toString());
292             }
293 
294             throw new NoSuchPasswordPolicyException(msg.toString());
295         }
296 
297         return passwordPolicy;
298     }
299 
300     public PasswordPolicy fetchByC_DP(long companyId, boolean defaultPolicy)
301         throws SystemException {
302         boolean finderClassNameCacheEnabled = PasswordPolicyModelImpl.CACHE_ENABLED;
303         String finderClassName = PasswordPolicy.class.getName();
304         String finderMethodName = "fetchByC_DP";
305         String[] finderParams = new String[] {
306                 Long.class.getName(), Boolean.class.getName()
307             };
308         Object[] finderArgs = new Object[] {
309                 new Long(companyId), Boolean.valueOf(defaultPolicy)
310             };
311 
312         Object result = null;
313 
314         if (finderClassNameCacheEnabled) {
315             result = FinderCache.getResult(finderClassName, finderMethodName,
316                     finderParams, finderArgs, getSessionFactory());
317         }
318 
319         if (result == null) {
320             Session session = null;
321 
322             try {
323                 session = openSession();
324 
325                 StringMaker query = new StringMaker();
326 
327                 query.append(
328                     "FROM com.liferay.portal.model.PasswordPolicy WHERE ");
329 
330                 query.append("companyId = ?");
331 
332                 query.append(" AND ");
333 
334                 query.append("defaultPolicy = ?");
335 
336                 query.append(" ");
337 
338                 Query q = session.createQuery(query.toString());
339 
340                 int queryPos = 0;
341 
342                 q.setLong(queryPos++, companyId);
343 
344                 q.setBoolean(queryPos++, defaultPolicy);
345 
346                 List<PasswordPolicy> list = q.list();
347 
348                 FinderCache.putResult(finderClassNameCacheEnabled,
349                     finderClassName, finderMethodName, finderParams,
350                     finderArgs, list);
351 
352                 if (list.size() == 0) {
353                     return null;
354                 }
355                 else {
356                     return list.get(0);
357                 }
358             }
359             catch (Exception e) {
360                 throw HibernateUtil.processException(e);
361             }
362             finally {
363                 closeSession(session);
364             }
365         }
366         else {
367             List<PasswordPolicy> list = (List<PasswordPolicy>)result;
368 
369             if (list.size() == 0) {
370                 return null;
371             }
372             else {
373                 return list.get(0);
374             }
375         }
376     }
377 
378     public PasswordPolicy findByC_N(long companyId, String name)
379         throws NoSuchPasswordPolicyException, SystemException {
380         PasswordPolicy passwordPolicy = fetchByC_N(companyId, name);
381 
382         if (passwordPolicy == null) {
383             StringMaker msg = new StringMaker();
384 
385             msg.append("No PasswordPolicy exists with the key {");
386 
387             msg.append("companyId=" + companyId);
388 
389             msg.append(", ");
390             msg.append("name=" + name);
391 
392             msg.append(StringPool.CLOSE_CURLY_BRACE);
393 
394             if (_log.isWarnEnabled()) {
395                 _log.warn(msg.toString());
396             }
397 
398             throw new NoSuchPasswordPolicyException(msg.toString());
399         }
400 
401         return passwordPolicy;
402     }
403 
404     public PasswordPolicy fetchByC_N(long companyId, String name)
405         throws SystemException {
406         boolean finderClassNameCacheEnabled = PasswordPolicyModelImpl.CACHE_ENABLED;
407         String finderClassName = PasswordPolicy.class.getName();
408         String finderMethodName = "fetchByC_N";
409         String[] finderParams = new String[] {
410                 Long.class.getName(), String.class.getName()
411             };
412         Object[] finderArgs = new Object[] { new Long(companyId), name };
413 
414         Object result = null;
415 
416         if (finderClassNameCacheEnabled) {
417             result = FinderCache.getResult(finderClassName, finderMethodName,
418                     finderParams, finderArgs, getSessionFactory());
419         }
420 
421         if (result == null) {
422             Session session = null;
423 
424             try {
425                 session = openSession();
426 
427                 StringMaker query = new StringMaker();
428 
429                 query.append(
430                     "FROM com.liferay.portal.model.PasswordPolicy WHERE ");
431 
432                 query.append("companyId = ?");
433 
434                 query.append(" AND ");
435 
436                 if (name == null) {
437                     query.append("name IS NULL");
438                 }
439                 else {
440                     query.append("name = ?");
441                 }
442 
443                 query.append(" ");
444 
445                 Query q = session.createQuery(query.toString());
446 
447                 int queryPos = 0;
448 
449                 q.setLong(queryPos++, companyId);
450 
451                 if (name != null) {
452                     q.setString(queryPos++, name);
453                 }
454 
455                 List<PasswordPolicy> list = q.list();
456 
457                 FinderCache.putResult(finderClassNameCacheEnabled,
458                     finderClassName, finderMethodName, finderParams,
459                     finderArgs, list);
460 
461                 if (list.size() == 0) {
462                     return null;
463                 }
464                 else {
465                     return list.get(0);
466                 }
467             }
468             catch (Exception e) {
469                 throw HibernateUtil.processException(e);
470             }
471             finally {
472                 closeSession(session);
473             }
474         }
475         else {
476             List<PasswordPolicy> list = (List<PasswordPolicy>)result;
477 
478             if (list.size() == 0) {
479                 return null;
480             }
481             else {
482                 return list.get(0);
483             }
484         }
485     }
486 
487     public List<PasswordPolicy> findWithDynamicQuery(
488         DynamicQueryInitializer queryInitializer) throws SystemException {
489         Session session = null;
490 
491         try {
492             session = openSession();
493 
494             DynamicQuery query = queryInitializer.initialize(session);
495 
496             return query.list();
497         }
498         catch (Exception e) {
499             throw HibernateUtil.processException(e);
500         }
501         finally {
502             closeSession(session);
503         }
504     }
505 
506     public List<PasswordPolicy> findWithDynamicQuery(
507         DynamicQueryInitializer queryInitializer, int begin, int end)
508         throws SystemException {
509         Session session = null;
510 
511         try {
512             session = openSession();
513 
514             DynamicQuery query = queryInitializer.initialize(session);
515 
516             query.setLimit(begin, end);
517 
518             return query.list();
519         }
520         catch (Exception e) {
521             throw HibernateUtil.processException(e);
522         }
523         finally {
524             closeSession(session);
525         }
526     }
527 
528     public List<PasswordPolicy> findAll() throws SystemException {
529         return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
530     }
531 
532     public List<PasswordPolicy> findAll(int begin, int end)
533         throws SystemException {
534         return findAll(begin, end, null);
535     }
536 
537     public List<PasswordPolicy> findAll(int begin, int end,
538         OrderByComparator obc) throws SystemException {
539         boolean finderClassNameCacheEnabled = PasswordPolicyModelImpl.CACHE_ENABLED;
540         String finderClassName = PasswordPolicy.class.getName();
541         String finderMethodName = "findAll";
542         String[] finderParams = new String[] {
543                 "java.lang.Integer", "java.lang.Integer",
544                 "com.liferay.portal.kernel.util.OrderByComparator"
545             };
546         Object[] finderArgs = new Object[] {
547                 String.valueOf(begin), String.valueOf(end), String.valueOf(obc)
548             };
549 
550         Object result = null;
551 
552         if (finderClassNameCacheEnabled) {
553             result = FinderCache.getResult(finderClassName, finderMethodName,
554                     finderParams, finderArgs, getSessionFactory());
555         }
556 
557         if (result == null) {
558             Session session = null;
559 
560             try {
561                 session = openSession();
562 
563                 StringMaker query = new StringMaker();
564 
565                 query.append("FROM com.liferay.portal.model.PasswordPolicy ");
566 
567                 if (obc != null) {
568                     query.append("ORDER BY ");
569                     query.append(obc.getOrderBy());
570                 }
571 
572                 Query q = session.createQuery(query.toString());
573 
574                 List<PasswordPolicy> list = (List<PasswordPolicy>)QueryUtil.list(q,
575                         getDialect(), begin, end);
576 
577                 if (obc == null) {
578                     Collections.sort(list);
579                 }
580 
581                 FinderCache.putResult(finderClassNameCacheEnabled,
582                     finderClassName, finderMethodName, finderParams,
583                     finderArgs, list);
584 
585                 return list;
586             }
587             catch (Exception e) {
588                 throw HibernateUtil.processException(e);
589             }
590             finally {
591                 closeSession(session);
592             }
593         }
594         else {
595             return (List<PasswordPolicy>)result;
596         }
597     }
598 
599     public void removeByC_DP(long companyId, boolean defaultPolicy)
600         throws NoSuchPasswordPolicyException, SystemException {
601         PasswordPolicy passwordPolicy = findByC_DP(companyId, defaultPolicy);
602 
603         remove(passwordPolicy);
604     }
605 
606     public void removeByC_N(long companyId, String name)
607         throws NoSuchPasswordPolicyException, SystemException {
608         PasswordPolicy passwordPolicy = findByC_N(companyId, name);
609 
610         remove(passwordPolicy);
611     }
612 
613     public void removeAll() throws SystemException {
614         for (PasswordPolicy passwordPolicy : findAll()) {
615             remove(passwordPolicy);
616         }
617     }
618 
619     public int countByC_DP(long companyId, boolean defaultPolicy)
620         throws SystemException {
621         boolean finderClassNameCacheEnabled = PasswordPolicyModelImpl.CACHE_ENABLED;
622         String finderClassName = PasswordPolicy.class.getName();
623         String finderMethodName = "countByC_DP";
624         String[] finderParams = new String[] {
625                 Long.class.getName(), Boolean.class.getName()
626             };
627         Object[] finderArgs = new Object[] {
628                 new Long(companyId), Boolean.valueOf(defaultPolicy)
629             };
630 
631         Object result = null;
632 
633         if (finderClassNameCacheEnabled) {
634             result = FinderCache.getResult(finderClassName, finderMethodName,
635                     finderParams, finderArgs, getSessionFactory());
636         }
637 
638         if (result == null) {
639             Session session = null;
640 
641             try {
642                 session = openSession();
643 
644                 StringMaker query = new StringMaker();
645 
646                 query.append("SELECT COUNT(*) ");
647                 query.append(
648                     "FROM com.liferay.portal.model.PasswordPolicy WHERE ");
649 
650                 query.append("companyId = ?");
651 
652                 query.append(" AND ");
653 
654                 query.append("defaultPolicy = ?");
655 
656                 query.append(" ");
657 
658                 Query q = session.createQuery(query.toString());
659 
660                 int queryPos = 0;
661 
662                 q.setLong(queryPos++, companyId);
663 
664                 q.setBoolean(queryPos++, defaultPolicy);
665 
666                 Long count = null;
667 
668                 Iterator<Long> itr = q.list().iterator();
669 
670                 if (itr.hasNext()) {
671                     count = itr.next();
672                 }
673 
674                 if (count == null) {
675                     count = new Long(0);
676                 }
677 
678                 FinderCache.putResult(finderClassNameCacheEnabled,
679                     finderClassName, finderMethodName, finderParams,
680                     finderArgs, count);
681 
682                 return count.intValue();
683             }
684             catch (Exception e) {
685                 throw HibernateUtil.processException(e);
686             }
687             finally {
688                 closeSession(session);
689             }
690         }
691         else {
692             return ((Long)result).intValue();
693         }
694     }
695 
696     public int countByC_N(long companyId, String name)
697         throws SystemException {
698         boolean finderClassNameCacheEnabled = PasswordPolicyModelImpl.CACHE_ENABLED;
699         String finderClassName = PasswordPolicy.class.getName();
700         String finderMethodName = "countByC_N";
701         String[] finderParams = new String[] {
702                 Long.class.getName(), String.class.getName()
703             };
704         Object[] finderArgs = new Object[] { new Long(companyId), name };
705 
706         Object result = null;
707 
708         if (finderClassNameCacheEnabled) {
709             result = FinderCache.getResult(finderClassName, finderMethodName,
710                     finderParams, finderArgs, getSessionFactory());
711         }
712 
713         if (result == null) {
714             Session session = null;
715 
716             try {
717                 session = openSession();
718 
719                 StringMaker query = new StringMaker();
720 
721                 query.append("SELECT COUNT(*) ");
722                 query.append(
723                     "FROM com.liferay.portal.model.PasswordPolicy WHERE ");
724 
725                 query.append("companyId = ?");
726 
727                 query.append(" AND ");
728 
729                 if (name == null) {
730                     query.append("name IS NULL");
731                 }
732                 else {
733                     query.append("name = ?");
734                 }
735 
736                 query.append(" ");
737 
738                 Query q = session.createQuery(query.toString());
739 
740                 int queryPos = 0;
741 
742                 q.setLong(queryPos++, companyId);
743 
744                 if (name != null) {
745                     q.setString(queryPos++, name);
746                 }
747 
748                 Long count = null;
749 
750                 Iterator<Long> itr = q.list().iterator();
751 
752                 if (itr.hasNext()) {
753                     count = itr.next();
754                 }
755 
756                 if (count == null) {
757                     count = new Long(0);
758                 }
759 
760                 FinderCache.putResult(finderClassNameCacheEnabled,
761                     finderClassName, finderMethodName, finderParams,
762                     finderArgs, count);
763 
764                 return count.intValue();
765             }
766             catch (Exception e) {
767                 throw HibernateUtil.processException(e);
768             }
769             finally {
770                 closeSession(session);
771             }
772         }
773         else {
774             return ((Long)result).intValue();
775         }
776     }
777 
778     public int countAll() throws SystemException {
779         boolean finderClassNameCacheEnabled = PasswordPolicyModelImpl.CACHE_ENABLED;
780         String finderClassName = PasswordPolicy.class.getName();
781         String finderMethodName = "countAll";
782         String[] finderParams = new String[] {  };
783         Object[] finderArgs = new Object[] {  };
784 
785         Object result = null;
786 
787         if (finderClassNameCacheEnabled) {
788             result = FinderCache.getResult(finderClassName, finderMethodName,
789                     finderParams, finderArgs, getSessionFactory());
790         }
791 
792         if (result == null) {
793             Session session = null;
794 
795             try {
796                 session = openSession();
797 
798                 Query q = session.createQuery(
799                         "SELECT COUNT(*) FROM com.liferay.portal.model.PasswordPolicy");
800 
801                 Long count = null;
802 
803                 Iterator<Long> itr = q.list().iterator();
804 
805                 if (itr.hasNext()) {
806                     count = itr.next();
807                 }
808 
809                 if (count == null) {
810                     count = new Long(0);
811                 }
812 
813                 FinderCache.putResult(finderClassNameCacheEnabled,
814                     finderClassName, finderMethodName, finderParams,
815                     finderArgs, count);
816 
817                 return count.intValue();
818             }
819             catch (Exception e) {
820                 throw HibernateUtil.processException(e);
821             }
822             finally {
823                 closeSession(session);
824             }
825         }
826         else {
827             return ((Long)result).intValue();
828         }
829     }
830 
831     protected void initDao() {
832         String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
833                     PropsUtil.get(
834                         "value.object.listener.com.liferay.portal.model.PasswordPolicy")));
835 
836         if (listenerClassNames.length > 0) {
837             try {
838                 List<ModelListener> listeners = new ArrayList<ModelListener>();
839 
840                 for (String listenerClassName : listenerClassNames) {
841                     listeners.add((ModelListener)Class.forName(
842                             listenerClassName).newInstance());
843                 }
844 
845                 _listeners = listeners.toArray(new ModelListener[listeners.size()]);
846             }
847             catch (Exception e) {
848                 _log.error(e);
849             }
850         }
851     }
852 
853     private static Log _log = LogFactory.getLog(PasswordPolicyPersistenceImpl.class);
854     private ModelListener[] _listeners;
855 }