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