1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * This library is free software; you can redistribute it and/or modify it under
5    * the terms of the GNU Lesser General Public License as published by the Free
6    * Software Foundation; either version 2.1 of the License, or (at your option)
7    * any later version.
8    *
9    * This library is distributed in the hope that it will be useful, but WITHOUT
10   * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
11   * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
12   * details.
13   */
14  
15  package com.liferay.portal.service.persistence;
16  
17  import com.liferay.portal.NoSuchModelException;
18  import com.liferay.portal.NoSuchPasswordPolicyException;
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.exception.SystemException;
29  import com.liferay.portal.kernel.log.Log;
30  import com.liferay.portal.kernel.log.LogFactoryUtil;
31  import com.liferay.portal.kernel.util.GetterUtil;
32  import com.liferay.portal.kernel.util.InstanceFactory;
33  import com.liferay.portal.kernel.util.OrderByComparator;
34  import com.liferay.portal.kernel.util.StringBundler;
35  import com.liferay.portal.kernel.util.StringPool;
36  import com.liferay.portal.kernel.util.StringUtil;
37  import com.liferay.portal.kernel.util.Validator;
38  import com.liferay.portal.model.ModelListener;
39  import com.liferay.portal.model.PasswordPolicy;
40  import com.liferay.portal.model.impl.PasswordPolicyImpl;
41  import com.liferay.portal.model.impl.PasswordPolicyModelImpl;
42  import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
43  
44  import java.io.Serializable;
45  
46  import java.util.ArrayList;
47  import java.util.Collections;
48  import java.util.List;
49  
50  /**
51   * <a href="PasswordPolicyPersistenceImpl.java.html"><b><i>View Source</i></b></a>
52   *
53   * <p>
54   * ServiceBuilder generated this class. Modifications in this class will be
55   * overwritten the next time is generated.
56   * </p>
57   *
58   * @author    Brian Wing Shun Chan
59   * @see       PasswordPolicyPersistence
60   * @see       PasswordPolicyUtil
61   * @generated
62   */
63  public class PasswordPolicyPersistenceImpl extends BasePersistenceImpl<PasswordPolicy>
64      implements PasswordPolicyPersistence {
65      public static final String FINDER_CLASS_NAME_ENTITY = PasswordPolicyImpl.class.getName();
66      public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
67          ".List";
68      public static final FinderPath FINDER_PATH_FETCH_BY_C_DP = new FinderPath(PasswordPolicyModelImpl.ENTITY_CACHE_ENABLED,
69              PasswordPolicyModelImpl.FINDER_CACHE_ENABLED,
70              FINDER_CLASS_NAME_ENTITY, "fetchByC_DP",
71              new String[] { Long.class.getName(), Boolean.class.getName() });
72      public static final FinderPath FINDER_PATH_COUNT_BY_C_DP = new FinderPath(PasswordPolicyModelImpl.ENTITY_CACHE_ENABLED,
73              PasswordPolicyModelImpl.FINDER_CACHE_ENABLED,
74              FINDER_CLASS_NAME_LIST, "countByC_DP",
75              new String[] { Long.class.getName(), Boolean.class.getName() });
76      public static final FinderPath FINDER_PATH_FETCH_BY_C_N = new FinderPath(PasswordPolicyModelImpl.ENTITY_CACHE_ENABLED,
77              PasswordPolicyModelImpl.FINDER_CACHE_ENABLED,
78              FINDER_CLASS_NAME_ENTITY, "fetchByC_N",
79              new String[] { Long.class.getName(), String.class.getName() });
80      public static final FinderPath FINDER_PATH_COUNT_BY_C_N = new FinderPath(PasswordPolicyModelImpl.ENTITY_CACHE_ENABLED,
81              PasswordPolicyModelImpl.FINDER_CACHE_ENABLED,
82              FINDER_CLASS_NAME_LIST, "countByC_N",
83              new String[] { Long.class.getName(), String.class.getName() });
84      public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(PasswordPolicyModelImpl.ENTITY_CACHE_ENABLED,
85              PasswordPolicyModelImpl.FINDER_CACHE_ENABLED,
86              FINDER_CLASS_NAME_LIST, "findAll", new String[0]);
87      public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(PasswordPolicyModelImpl.ENTITY_CACHE_ENABLED,
88              PasswordPolicyModelImpl.FINDER_CACHE_ENABLED,
89              FINDER_CLASS_NAME_LIST, "countAll", new String[0]);
90  
91      public void cacheResult(PasswordPolicy passwordPolicy) {
92          EntityCacheUtil.putResult(PasswordPolicyModelImpl.ENTITY_CACHE_ENABLED,
93              PasswordPolicyImpl.class, passwordPolicy.getPrimaryKey(),
94              passwordPolicy);
95  
96          FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_DP,
97              new Object[] {
98                  new Long(passwordPolicy.getCompanyId()),
99                  Boolean.valueOf(passwordPolicy.getDefaultPolicy())
100             }, passwordPolicy);
101 
102         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_N,
103             new Object[] {
104                 new Long(passwordPolicy.getCompanyId()),
105                 
106             passwordPolicy.getName()
107             }, passwordPolicy);
108     }
109 
110     public void cacheResult(List<PasswordPolicy> passwordPolicies) {
111         for (PasswordPolicy passwordPolicy : passwordPolicies) {
112             if (EntityCacheUtil.getResult(
113                         PasswordPolicyModelImpl.ENTITY_CACHE_ENABLED,
114                         PasswordPolicyImpl.class,
115                         passwordPolicy.getPrimaryKey(), this) == null) {
116                 cacheResult(passwordPolicy);
117             }
118         }
119     }
120 
121     public void clearCache() {
122         CacheRegistry.clear(PasswordPolicyImpl.class.getName());
123         EntityCacheUtil.clearCache(PasswordPolicyImpl.class.getName());
124         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
125         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
126     }
127 
128     public void clearCache(PasswordPolicy passwordPolicy) {
129         EntityCacheUtil.removeResult(PasswordPolicyModelImpl.ENTITY_CACHE_ENABLED,
130             PasswordPolicyImpl.class, passwordPolicy.getPrimaryKey());
131 
132         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_DP,
133             new Object[] {
134                 new Long(passwordPolicy.getCompanyId()),
135                 Boolean.valueOf(passwordPolicy.getDefaultPolicy())
136             });
137 
138         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_N,
139             new Object[] {
140                 new Long(passwordPolicy.getCompanyId()),
141                 
142             passwordPolicy.getName()
143             });
144     }
145 
146     public PasswordPolicy create(long passwordPolicyId) {
147         PasswordPolicy passwordPolicy = new PasswordPolicyImpl();
148 
149         passwordPolicy.setNew(true);
150         passwordPolicy.setPrimaryKey(passwordPolicyId);
151 
152         return passwordPolicy;
153     }
154 
155     public PasswordPolicy remove(Serializable primaryKey)
156         throws NoSuchModelException, SystemException {
157         return remove(((Long)primaryKey).longValue());
158     }
159 
160     public PasswordPolicy remove(long passwordPolicyId)
161         throws NoSuchPasswordPolicyException, SystemException {
162         Session session = null;
163 
164         try {
165             session = openSession();
166 
167             PasswordPolicy passwordPolicy = (PasswordPolicy)session.get(PasswordPolicyImpl.class,
168                     new Long(passwordPolicyId));
169 
170             if (passwordPolicy == null) {
171                 if (_log.isWarnEnabled()) {
172                     _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
173                         passwordPolicyId);
174                 }
175 
176                 throw new NoSuchPasswordPolicyException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
177                     passwordPolicyId);
178             }
179 
180             return remove(passwordPolicy);
181         }
182         catch (NoSuchPasswordPolicyException nsee) {
183             throw nsee;
184         }
185         catch (Exception e) {
186             throw processException(e);
187         }
188         finally {
189             closeSession(session);
190         }
191     }
192 
193     public PasswordPolicy remove(PasswordPolicy passwordPolicy)
194         throws SystemException {
195         for (ModelListener<PasswordPolicy> listener : listeners) {
196             listener.onBeforeRemove(passwordPolicy);
197         }
198 
199         passwordPolicy = removeImpl(passwordPolicy);
200 
201         for (ModelListener<PasswordPolicy> listener : listeners) {
202             listener.onAfterRemove(passwordPolicy);
203         }
204 
205         return passwordPolicy;
206     }
207 
208     protected PasswordPolicy removeImpl(PasswordPolicy passwordPolicy)
209         throws SystemException {
210         passwordPolicy = toUnwrappedModel(passwordPolicy);
211 
212         Session session = null;
213 
214         try {
215             session = openSession();
216 
217             if (passwordPolicy.isCachedModel() || BatchSessionUtil.isEnabled()) {
218                 Object staleObject = session.get(PasswordPolicyImpl.class,
219                         passwordPolicy.getPrimaryKeyObj());
220 
221                 if (staleObject != null) {
222                     session.evict(staleObject);
223                 }
224             }
225 
226             session.delete(passwordPolicy);
227 
228             session.flush();
229         }
230         catch (Exception e) {
231             throw processException(e);
232         }
233         finally {
234             closeSession(session);
235         }
236 
237         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
238 
239         PasswordPolicyModelImpl passwordPolicyModelImpl = (PasswordPolicyModelImpl)passwordPolicy;
240 
241         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_DP,
242             new Object[] {
243                 new Long(passwordPolicyModelImpl.getOriginalCompanyId()),
244                 Boolean.valueOf(
245                     passwordPolicyModelImpl.getOriginalDefaultPolicy())
246             });
247 
248         FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_N,
249             new Object[] {
250                 new Long(passwordPolicyModelImpl.getOriginalCompanyId()),
251                 
252             passwordPolicyModelImpl.getOriginalName()
253             });
254 
255         EntityCacheUtil.removeResult(PasswordPolicyModelImpl.ENTITY_CACHE_ENABLED,
256             PasswordPolicyImpl.class, passwordPolicy.getPrimaryKey());
257 
258         return passwordPolicy;
259     }
260 
261     public PasswordPolicy updateImpl(
262         com.liferay.portal.model.PasswordPolicy passwordPolicy, boolean merge)
263         throws SystemException {
264         passwordPolicy = toUnwrappedModel(passwordPolicy);
265 
266         boolean isNew = passwordPolicy.isNew();
267 
268         PasswordPolicyModelImpl passwordPolicyModelImpl = (PasswordPolicyModelImpl)passwordPolicy;
269 
270         Session session = null;
271 
272         try {
273             session = openSession();
274 
275             BatchSessionUtil.update(session, passwordPolicy, merge);
276 
277             passwordPolicy.setNew(false);
278         }
279         catch (Exception e) {
280             throw processException(e);
281         }
282         finally {
283             closeSession(session);
284         }
285 
286         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
287 
288         EntityCacheUtil.putResult(PasswordPolicyModelImpl.ENTITY_CACHE_ENABLED,
289             PasswordPolicyImpl.class, passwordPolicy.getPrimaryKey(),
290             passwordPolicy);
291 
292         if (!isNew &&
293                 ((passwordPolicy.getCompanyId() != passwordPolicyModelImpl.getOriginalCompanyId()) ||
294                 (passwordPolicy.getDefaultPolicy() != passwordPolicyModelImpl.getOriginalDefaultPolicy()))) {
295             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_DP,
296                 new Object[] {
297                     new Long(passwordPolicyModelImpl.getOriginalCompanyId()),
298                     Boolean.valueOf(
299                         passwordPolicyModelImpl.getOriginalDefaultPolicy())
300                 });
301         }
302 
303         if (isNew ||
304                 ((passwordPolicy.getCompanyId() != passwordPolicyModelImpl.getOriginalCompanyId()) ||
305                 (passwordPolicy.getDefaultPolicy() != passwordPolicyModelImpl.getOriginalDefaultPolicy()))) {
306             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_DP,
307                 new Object[] {
308                     new Long(passwordPolicy.getCompanyId()),
309                     Boolean.valueOf(passwordPolicy.getDefaultPolicy())
310                 }, passwordPolicy);
311         }
312 
313         if (!isNew &&
314                 ((passwordPolicy.getCompanyId() != passwordPolicyModelImpl.getOriginalCompanyId()) ||
315                 !Validator.equals(passwordPolicy.getName(),
316                     passwordPolicyModelImpl.getOriginalName()))) {
317             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_N,
318                 new Object[] {
319                     new Long(passwordPolicyModelImpl.getOriginalCompanyId()),
320                     
321                 passwordPolicyModelImpl.getOriginalName()
322                 });
323         }
324 
325         if (isNew ||
326                 ((passwordPolicy.getCompanyId() != passwordPolicyModelImpl.getOriginalCompanyId()) ||
327                 !Validator.equals(passwordPolicy.getName(),
328                     passwordPolicyModelImpl.getOriginalName()))) {
329             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_N,
330                 new Object[] {
331                     new Long(passwordPolicy.getCompanyId()),
332                     
333                 passwordPolicy.getName()
334                 }, passwordPolicy);
335         }
336 
337         return passwordPolicy;
338     }
339 
340     protected PasswordPolicy toUnwrappedModel(PasswordPolicy passwordPolicy) {
341         if (passwordPolicy instanceof PasswordPolicyImpl) {
342             return passwordPolicy;
343         }
344 
345         PasswordPolicyImpl passwordPolicyImpl = new PasswordPolicyImpl();
346 
347         passwordPolicyImpl.setNew(passwordPolicy.isNew());
348         passwordPolicyImpl.setPrimaryKey(passwordPolicy.getPrimaryKey());
349 
350         passwordPolicyImpl.setPasswordPolicyId(passwordPolicy.getPasswordPolicyId());
351         passwordPolicyImpl.setCompanyId(passwordPolicy.getCompanyId());
352         passwordPolicyImpl.setUserId(passwordPolicy.getUserId());
353         passwordPolicyImpl.setUserName(passwordPolicy.getUserName());
354         passwordPolicyImpl.setCreateDate(passwordPolicy.getCreateDate());
355         passwordPolicyImpl.setModifiedDate(passwordPolicy.getModifiedDate());
356         passwordPolicyImpl.setDefaultPolicy(passwordPolicy.isDefaultPolicy());
357         passwordPolicyImpl.setName(passwordPolicy.getName());
358         passwordPolicyImpl.setDescription(passwordPolicy.getDescription());
359         passwordPolicyImpl.setChangeable(passwordPolicy.isChangeable());
360         passwordPolicyImpl.setChangeRequired(passwordPolicy.isChangeRequired());
361         passwordPolicyImpl.setMinAge(passwordPolicy.getMinAge());
362         passwordPolicyImpl.setCheckSyntax(passwordPolicy.isCheckSyntax());
363         passwordPolicyImpl.setAllowDictionaryWords(passwordPolicy.isAllowDictionaryWords());
364         passwordPolicyImpl.setMinAlphanumeric(passwordPolicy.getMinAlphanumeric());
365         passwordPolicyImpl.setMinLength(passwordPolicy.getMinLength());
366         passwordPolicyImpl.setMinLowerCase(passwordPolicy.getMinLowerCase());
367         passwordPolicyImpl.setMinNumbers(passwordPolicy.getMinNumbers());
368         passwordPolicyImpl.setMinSymbols(passwordPolicy.getMinSymbols());
369         passwordPolicyImpl.setMinUpperCase(passwordPolicy.getMinUpperCase());
370         passwordPolicyImpl.setHistory(passwordPolicy.isHistory());
371         passwordPolicyImpl.setHistoryCount(passwordPolicy.getHistoryCount());
372         passwordPolicyImpl.setExpireable(passwordPolicy.isExpireable());
373         passwordPolicyImpl.setMaxAge(passwordPolicy.getMaxAge());
374         passwordPolicyImpl.setWarningTime(passwordPolicy.getWarningTime());
375         passwordPolicyImpl.setGraceLimit(passwordPolicy.getGraceLimit());
376         passwordPolicyImpl.setLockout(passwordPolicy.isLockout());
377         passwordPolicyImpl.setMaxFailure(passwordPolicy.getMaxFailure());
378         passwordPolicyImpl.setLockoutDuration(passwordPolicy.getLockoutDuration());
379         passwordPolicyImpl.setRequireUnlock(passwordPolicy.isRequireUnlock());
380         passwordPolicyImpl.setResetFailureCount(passwordPolicy.getResetFailureCount());
381         passwordPolicyImpl.setResetTicketMaxAge(passwordPolicy.getResetTicketMaxAge());
382 
383         return passwordPolicyImpl;
384     }
385 
386     public PasswordPolicy findByPrimaryKey(Serializable primaryKey)
387         throws NoSuchModelException, SystemException {
388         return findByPrimaryKey(((Long)primaryKey).longValue());
389     }
390 
391     public PasswordPolicy findByPrimaryKey(long passwordPolicyId)
392         throws NoSuchPasswordPolicyException, SystemException {
393         PasswordPolicy passwordPolicy = fetchByPrimaryKey(passwordPolicyId);
394 
395         if (passwordPolicy == null) {
396             if (_log.isWarnEnabled()) {
397                 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + passwordPolicyId);
398             }
399 
400             throw new NoSuchPasswordPolicyException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
401                 passwordPolicyId);
402         }
403 
404         return passwordPolicy;
405     }
406 
407     public PasswordPolicy fetchByPrimaryKey(Serializable primaryKey)
408         throws SystemException {
409         return fetchByPrimaryKey(((Long)primaryKey).longValue());
410     }
411 
412     public PasswordPolicy fetchByPrimaryKey(long passwordPolicyId)
413         throws SystemException {
414         PasswordPolicy passwordPolicy = (PasswordPolicy)EntityCacheUtil.getResult(PasswordPolicyModelImpl.ENTITY_CACHE_ENABLED,
415                 PasswordPolicyImpl.class, passwordPolicyId, this);
416 
417         if (passwordPolicy == null) {
418             Session session = null;
419 
420             try {
421                 session = openSession();
422 
423                 passwordPolicy = (PasswordPolicy)session.get(PasswordPolicyImpl.class,
424                         new Long(passwordPolicyId));
425             }
426             catch (Exception e) {
427                 throw processException(e);
428             }
429             finally {
430                 if (passwordPolicy != null) {
431                     cacheResult(passwordPolicy);
432                 }
433 
434                 closeSession(session);
435             }
436         }
437 
438         return passwordPolicy;
439     }
440 
441     public PasswordPolicy findByC_DP(long companyId, boolean defaultPolicy)
442         throws NoSuchPasswordPolicyException, SystemException {
443         PasswordPolicy passwordPolicy = fetchByC_DP(companyId, defaultPolicy);
444 
445         if (passwordPolicy == null) {
446             StringBundler msg = new StringBundler(6);
447 
448             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
449 
450             msg.append("companyId=");
451             msg.append(companyId);
452 
453             msg.append(", defaultPolicy=");
454             msg.append(defaultPolicy);
455 
456             msg.append(StringPool.CLOSE_CURLY_BRACE);
457 
458             if (_log.isWarnEnabled()) {
459                 _log.warn(msg.toString());
460             }
461 
462             throw new NoSuchPasswordPolicyException(msg.toString());
463         }
464 
465         return passwordPolicy;
466     }
467 
468     public PasswordPolicy fetchByC_DP(long companyId, boolean defaultPolicy)
469         throws SystemException {
470         return fetchByC_DP(companyId, defaultPolicy, true);
471     }
472 
473     public PasswordPolicy fetchByC_DP(long companyId, boolean defaultPolicy,
474         boolean retrieveFromCache) throws SystemException {
475         Object[] finderArgs = new Object[] {
476                 new Long(companyId), Boolean.valueOf(defaultPolicy)
477             };
478 
479         Object result = null;
480 
481         if (retrieveFromCache) {
482             result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_C_DP,
483                     finderArgs, this);
484         }
485 
486         if (result == null) {
487             Session session = null;
488 
489             try {
490                 session = openSession();
491 
492                 StringBundler query = new StringBundler(3);
493 
494                 query.append(_SQL_SELECT_PASSWORDPOLICY_WHERE);
495 
496                 query.append(_FINDER_COLUMN_C_DP_COMPANYID_2);
497 
498                 query.append(_FINDER_COLUMN_C_DP_DEFAULTPOLICY_2);
499 
500                 String sql = query.toString();
501 
502                 Query q = session.createQuery(sql);
503 
504                 QueryPos qPos = QueryPos.getInstance(q);
505 
506                 qPos.add(companyId);
507 
508                 qPos.add(defaultPolicy);
509 
510                 List<PasswordPolicy> list = q.list();
511 
512                 result = list;
513 
514                 PasswordPolicy passwordPolicy = null;
515 
516                 if (list.isEmpty()) {
517                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_DP,
518                         finderArgs, list);
519                 }
520                 else {
521                     passwordPolicy = list.get(0);
522 
523                     cacheResult(passwordPolicy);
524 
525                     if ((passwordPolicy.getCompanyId() != companyId) ||
526                             (passwordPolicy.getDefaultPolicy() != defaultPolicy)) {
527                         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_DP,
528                             finderArgs, passwordPolicy);
529                     }
530                 }
531 
532                 return passwordPolicy;
533             }
534             catch (Exception e) {
535                 throw processException(e);
536             }
537             finally {
538                 if (result == null) {
539                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_DP,
540                         finderArgs, new ArrayList<PasswordPolicy>());
541                 }
542 
543                 closeSession(session);
544             }
545         }
546         else {
547             if (result instanceof List<?>) {
548                 return null;
549             }
550             else {
551                 return (PasswordPolicy)result;
552             }
553         }
554     }
555 
556     public PasswordPolicy findByC_N(long companyId, String name)
557         throws NoSuchPasswordPolicyException, SystemException {
558         PasswordPolicy passwordPolicy = fetchByC_N(companyId, name);
559 
560         if (passwordPolicy == null) {
561             StringBundler msg = new StringBundler(6);
562 
563             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
564 
565             msg.append("companyId=");
566             msg.append(companyId);
567 
568             msg.append(", name=");
569             msg.append(name);
570 
571             msg.append(StringPool.CLOSE_CURLY_BRACE);
572 
573             if (_log.isWarnEnabled()) {
574                 _log.warn(msg.toString());
575             }
576 
577             throw new NoSuchPasswordPolicyException(msg.toString());
578         }
579 
580         return passwordPolicy;
581     }
582 
583     public PasswordPolicy fetchByC_N(long companyId, String name)
584         throws SystemException {
585         return fetchByC_N(companyId, name, true);
586     }
587 
588     public PasswordPolicy fetchByC_N(long companyId, String name,
589         boolean retrieveFromCache) throws SystemException {
590         Object[] finderArgs = new Object[] { new Long(companyId), name };
591 
592         Object result = null;
593 
594         if (retrieveFromCache) {
595             result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_C_N,
596                     finderArgs, this);
597         }
598 
599         if (result == null) {
600             Session session = null;
601 
602             try {
603                 session = openSession();
604 
605                 StringBundler query = new StringBundler(3);
606 
607                 query.append(_SQL_SELECT_PASSWORDPOLICY_WHERE);
608 
609                 query.append(_FINDER_COLUMN_C_N_COMPANYID_2);
610 
611                 if (name == null) {
612                     query.append(_FINDER_COLUMN_C_N_NAME_1);
613                 }
614                 else {
615                     if (name.equals(StringPool.BLANK)) {
616                         query.append(_FINDER_COLUMN_C_N_NAME_3);
617                     }
618                     else {
619                         query.append(_FINDER_COLUMN_C_N_NAME_2);
620                     }
621                 }
622 
623                 String sql = query.toString();
624 
625                 Query q = session.createQuery(sql);
626 
627                 QueryPos qPos = QueryPos.getInstance(q);
628 
629                 qPos.add(companyId);
630 
631                 if (name != null) {
632                     qPos.add(name);
633                 }
634 
635                 List<PasswordPolicy> list = q.list();
636 
637                 result = list;
638 
639                 PasswordPolicy passwordPolicy = null;
640 
641                 if (list.isEmpty()) {
642                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_N,
643                         finderArgs, list);
644                 }
645                 else {
646                     passwordPolicy = list.get(0);
647 
648                     cacheResult(passwordPolicy);
649 
650                     if ((passwordPolicy.getCompanyId() != companyId) ||
651                             (passwordPolicy.getName() == null) ||
652                             !passwordPolicy.getName().equals(name)) {
653                         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_N,
654                             finderArgs, passwordPolicy);
655                     }
656                 }
657 
658                 return passwordPolicy;
659             }
660             catch (Exception e) {
661                 throw processException(e);
662             }
663             finally {
664                 if (result == null) {
665                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_N,
666                         finderArgs, new ArrayList<PasswordPolicy>());
667                 }
668 
669                 closeSession(session);
670             }
671         }
672         else {
673             if (result instanceof List<?>) {
674                 return null;
675             }
676             else {
677                 return (PasswordPolicy)result;
678             }
679         }
680     }
681 
682     public List<PasswordPolicy> findAll() throws SystemException {
683         return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
684     }
685 
686     public List<PasswordPolicy> findAll(int start, int end)
687         throws SystemException {
688         return findAll(start, end, null);
689     }
690 
691     public List<PasswordPolicy> findAll(int start, int end,
692         OrderByComparator orderByComparator) throws SystemException {
693         Object[] finderArgs = new Object[] {
694                 String.valueOf(start), String.valueOf(end),
695                 String.valueOf(orderByComparator)
696             };
697 
698         List<PasswordPolicy> list = (List<PasswordPolicy>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
699                 finderArgs, this);
700 
701         if (list == null) {
702             Session session = null;
703 
704             try {
705                 session = openSession();
706 
707                 StringBundler query = null;
708                 String sql = null;
709 
710                 if (orderByComparator != null) {
711                     query = new StringBundler(2 +
712                             (orderByComparator.getOrderByFields().length * 3));
713 
714                     query.append(_SQL_SELECT_PASSWORDPOLICY);
715 
716                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
717                         orderByComparator);
718 
719                     sql = query.toString();
720                 }
721 
722                 sql = _SQL_SELECT_PASSWORDPOLICY;
723 
724                 Query q = session.createQuery(sql);
725 
726                 if (orderByComparator == null) {
727                     list = (List<PasswordPolicy>)QueryUtil.list(q,
728                             getDialect(), start, end, false);
729 
730                     Collections.sort(list);
731                 }
732                 else {
733                     list = (List<PasswordPolicy>)QueryUtil.list(q,
734                             getDialect(), start, end);
735                 }
736             }
737             catch (Exception e) {
738                 throw processException(e);
739             }
740             finally {
741                 if (list == null) {
742                     list = new ArrayList<PasswordPolicy>();
743                 }
744 
745                 cacheResult(list);
746 
747                 FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
748 
749                 closeSession(session);
750             }
751         }
752 
753         return list;
754     }
755 
756     public void removeByC_DP(long companyId, boolean defaultPolicy)
757         throws NoSuchPasswordPolicyException, SystemException {
758         PasswordPolicy passwordPolicy = findByC_DP(companyId, defaultPolicy);
759 
760         remove(passwordPolicy);
761     }
762 
763     public void removeByC_N(long companyId, String name)
764         throws NoSuchPasswordPolicyException, SystemException {
765         PasswordPolicy passwordPolicy = findByC_N(companyId, name);
766 
767         remove(passwordPolicy);
768     }
769 
770     public void removeAll() throws SystemException {
771         for (PasswordPolicy passwordPolicy : findAll()) {
772             remove(passwordPolicy);
773         }
774     }
775 
776     public int countByC_DP(long companyId, boolean defaultPolicy)
777         throws SystemException {
778         Object[] finderArgs = new Object[] {
779                 new Long(companyId), Boolean.valueOf(defaultPolicy)
780             };
781 
782         Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_DP,
783                 finderArgs, this);
784 
785         if (count == null) {
786             Session session = null;
787 
788             try {
789                 session = openSession();
790 
791                 StringBundler query = new StringBundler(3);
792 
793                 query.append(_SQL_COUNT_PASSWORDPOLICY_WHERE);
794 
795                 query.append(_FINDER_COLUMN_C_DP_COMPANYID_2);
796 
797                 query.append(_FINDER_COLUMN_C_DP_DEFAULTPOLICY_2);
798 
799                 String sql = query.toString();
800 
801                 Query q = session.createQuery(sql);
802 
803                 QueryPos qPos = QueryPos.getInstance(q);
804 
805                 qPos.add(companyId);
806 
807                 qPos.add(defaultPolicy);
808 
809                 count = (Long)q.uniqueResult();
810             }
811             catch (Exception e) {
812                 throw processException(e);
813             }
814             finally {
815                 if (count == null) {
816                     count = Long.valueOf(0);
817                 }
818 
819                 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_DP,
820                     finderArgs, count);
821 
822                 closeSession(session);
823             }
824         }
825 
826         return count.intValue();
827     }
828 
829     public int countByC_N(long companyId, String name)
830         throws SystemException {
831         Object[] finderArgs = new Object[] { new Long(companyId), name };
832 
833         Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_N,
834                 finderArgs, this);
835 
836         if (count == null) {
837             Session session = null;
838 
839             try {
840                 session = openSession();
841 
842                 StringBundler query = new StringBundler(3);
843 
844                 query.append(_SQL_COUNT_PASSWORDPOLICY_WHERE);
845 
846                 query.append(_FINDER_COLUMN_C_N_COMPANYID_2);
847 
848                 if (name == null) {
849                     query.append(_FINDER_COLUMN_C_N_NAME_1);
850                 }
851                 else {
852                     if (name.equals(StringPool.BLANK)) {
853                         query.append(_FINDER_COLUMN_C_N_NAME_3);
854                     }
855                     else {
856                         query.append(_FINDER_COLUMN_C_N_NAME_2);
857                     }
858                 }
859 
860                 String sql = query.toString();
861 
862                 Query q = session.createQuery(sql);
863 
864                 QueryPos qPos = QueryPos.getInstance(q);
865 
866                 qPos.add(companyId);
867 
868                 if (name != null) {
869                     qPos.add(name);
870                 }
871 
872                 count = (Long)q.uniqueResult();
873             }
874             catch (Exception e) {
875                 throw processException(e);
876             }
877             finally {
878                 if (count == null) {
879                     count = Long.valueOf(0);
880                 }
881 
882                 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_N, finderArgs,
883                     count);
884 
885                 closeSession(session);
886             }
887         }
888 
889         return count.intValue();
890     }
891 
892     public int countAll() throws SystemException {
893         Object[] finderArgs = new Object[0];
894 
895         Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
896                 finderArgs, this);
897 
898         if (count == null) {
899             Session session = null;
900 
901             try {
902                 session = openSession();
903 
904                 Query q = session.createQuery(_SQL_COUNT_PASSWORDPOLICY);
905 
906                 count = (Long)q.uniqueResult();
907             }
908             catch (Exception e) {
909                 throw processException(e);
910             }
911             finally {
912                 if (count == null) {
913                     count = Long.valueOf(0);
914                 }
915 
916                 FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
917                     count);
918 
919                 closeSession(session);
920             }
921         }
922 
923         return count.intValue();
924     }
925 
926     public void afterPropertiesSet() {
927         String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
928                     com.liferay.portal.util.PropsUtil.get(
929                         "value.object.listener.com.liferay.portal.model.PasswordPolicy")));
930 
931         if (listenerClassNames.length > 0) {
932             try {
933                 List<ModelListener<PasswordPolicy>> listenersList = new ArrayList<ModelListener<PasswordPolicy>>();
934 
935                 for (String listenerClassName : listenerClassNames) {
936                     listenersList.add((ModelListener<PasswordPolicy>)InstanceFactory.newInstance(
937                             listenerClassName));
938                 }
939 
940                 listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
941             }
942             catch (Exception e) {
943                 _log.error(e);
944             }
945         }
946     }
947 
948     @BeanReference(type = AccountPersistence.class)
949     protected AccountPersistence accountPersistence;
950     @BeanReference(type = AddressPersistence.class)
951     protected AddressPersistence addressPersistence;
952     @BeanReference(type = BrowserTrackerPersistence.class)
953     protected BrowserTrackerPersistence browserTrackerPersistence;
954     @BeanReference(type = ClassNamePersistence.class)
955     protected ClassNamePersistence classNamePersistence;
956     @BeanReference(type = CompanyPersistence.class)
957     protected CompanyPersistence companyPersistence;
958     @BeanReference(type = ContactPersistence.class)
959     protected ContactPersistence contactPersistence;
960     @BeanReference(type = CountryPersistence.class)
961     protected CountryPersistence countryPersistence;
962     @BeanReference(type = EmailAddressPersistence.class)
963     protected EmailAddressPersistence emailAddressPersistence;
964     @BeanReference(type = GroupPersistence.class)
965     protected GroupPersistence groupPersistence;
966     @BeanReference(type = ImagePersistence.class)
967     protected ImagePersistence imagePersistence;
968     @BeanReference(type = LayoutPersistence.class)
969     protected LayoutPersistence layoutPersistence;
970     @BeanReference(type = LayoutPrototypePersistence.class)
971     protected LayoutPrototypePersistence layoutPrototypePersistence;
972     @BeanReference(type = LayoutSetPersistence.class)
973     protected LayoutSetPersistence layoutSetPersistence;
974     @BeanReference(type = LayoutSetPrototypePersistence.class)
975     protected LayoutSetPrototypePersistence layoutSetPrototypePersistence;
976     @BeanReference(type = ListTypePersistence.class)
977     protected ListTypePersistence listTypePersistence;
978     @BeanReference(type = LockPersistence.class)
979     protected LockPersistence lockPersistence;
980     @BeanReference(type = MembershipRequestPersistence.class)
981     protected MembershipRequestPersistence membershipRequestPersistence;
982     @BeanReference(type = OrganizationPersistence.class)
983     protected OrganizationPersistence organizationPersistence;
984     @BeanReference(type = OrgGroupPermissionPersistence.class)
985     protected OrgGroupPermissionPersistence orgGroupPermissionPersistence;
986     @BeanReference(type = OrgGroupRolePersistence.class)
987     protected OrgGroupRolePersistence orgGroupRolePersistence;
988     @BeanReference(type = OrgLaborPersistence.class)
989     protected OrgLaborPersistence orgLaborPersistence;
990     @BeanReference(type = PasswordPolicyPersistence.class)
991     protected PasswordPolicyPersistence passwordPolicyPersistence;
992     @BeanReference(type = PasswordPolicyRelPersistence.class)
993     protected PasswordPolicyRelPersistence passwordPolicyRelPersistence;
994     @BeanReference(type = PasswordTrackerPersistence.class)
995     protected PasswordTrackerPersistence passwordTrackerPersistence;
996     @BeanReference(type = PermissionPersistence.class)
997     protected PermissionPersistence permissionPersistence;
998     @BeanReference(type = PhonePersistence.class)
999     protected PhonePersistence phonePersistence;
1000    @BeanReference(type = PluginSettingPersistence.class)
1001    protected PluginSettingPersistence pluginSettingPersistence;
1002    @BeanReference(type = PortletPersistence.class)
1003    protected PortletPersistence portletPersistence;
1004    @BeanReference(type = PortletItemPersistence.class)
1005    protected PortletItemPersistence portletItemPersistence;
1006    @BeanReference(type = PortletPreferencesPersistence.class)
1007    protected PortletPreferencesPersistence portletPreferencesPersistence;
1008    @BeanReference(type = RegionPersistence.class)
1009    protected RegionPersistence regionPersistence;
1010    @BeanReference(type = ReleasePersistence.class)
1011    protected ReleasePersistence releasePersistence;
1012    @BeanReference(type = ResourcePersistence.class)
1013    protected ResourcePersistence resourcePersistence;
1014    @BeanReference(type = ResourceActionPersistence.class)
1015    protected ResourceActionPersistence resourceActionPersistence;
1016    @BeanReference(type = ResourceCodePersistence.class)
1017    protected ResourceCodePersistence resourceCodePersistence;
1018    @BeanReference(type = ResourcePermissionPersistence.class)
1019    protected ResourcePermissionPersistence resourcePermissionPersistence;
1020    @BeanReference(type = RolePersistence.class)
1021    protected RolePersistence rolePersistence;
1022    @BeanReference(type = ServiceComponentPersistence.class)
1023    protected ServiceComponentPersistence serviceComponentPersistence;
1024    @BeanReference(type = ShardPersistence.class)
1025    protected ShardPersistence shardPersistence;
1026    @BeanReference(type = SubscriptionPersistence.class)
1027    protected SubscriptionPersistence subscriptionPersistence;
1028    @BeanReference(type = TicketPersistence.class)
1029    protected TicketPersistence ticketPersistence;
1030    @BeanReference(type = TeamPersistence.class)
1031    protected TeamPersistence teamPersistence;
1032    @BeanReference(type = UserPersistence.class)
1033    protected UserPersistence userPersistence;
1034    @BeanReference(type = UserGroupPersistence.class)
1035    protected UserGroupPersistence userGroupPersistence;
1036    @BeanReference(type = UserGroupGroupRolePersistence.class)
1037    protected UserGroupGroupRolePersistence userGroupGroupRolePersistence;
1038    @BeanReference(type = UserGroupRolePersistence.class)
1039    protected UserGroupRolePersistence userGroupRolePersistence;
1040    @BeanReference(type = UserIdMapperPersistence.class)
1041    protected UserIdMapperPersistence userIdMapperPersistence;
1042    @BeanReference(type = UserTrackerPersistence.class)
1043    protected UserTrackerPersistence userTrackerPersistence;
1044    @BeanReference(type = UserTrackerPathPersistence.class)
1045    protected UserTrackerPathPersistence userTrackerPathPersistence;
1046    @BeanReference(type = WebDAVPropsPersistence.class)
1047    protected WebDAVPropsPersistence webDAVPropsPersistence;
1048    @BeanReference(type = WebsitePersistence.class)
1049    protected WebsitePersistence websitePersistence;
1050    @BeanReference(type = WorkflowDefinitionLinkPersistence.class)
1051    protected WorkflowDefinitionLinkPersistence workflowDefinitionLinkPersistence;
1052    @BeanReference(type = WorkflowInstanceLinkPersistence.class)
1053    protected WorkflowInstanceLinkPersistence workflowInstanceLinkPersistence;
1054    private static final String _SQL_SELECT_PASSWORDPOLICY = "SELECT passwordPolicy FROM PasswordPolicy passwordPolicy";
1055    private static final String _SQL_SELECT_PASSWORDPOLICY_WHERE = "SELECT passwordPolicy FROM PasswordPolicy passwordPolicy WHERE ";
1056    private static final String _SQL_COUNT_PASSWORDPOLICY = "SELECT COUNT(passwordPolicy) FROM PasswordPolicy passwordPolicy";
1057    private static final String _SQL_COUNT_PASSWORDPOLICY_WHERE = "SELECT COUNT(passwordPolicy) FROM PasswordPolicy passwordPolicy WHERE ";
1058    private static final String _FINDER_COLUMN_C_DP_COMPANYID_2 = "passwordPolicy.companyId = ? AND ";
1059    private static final String _FINDER_COLUMN_C_DP_DEFAULTPOLICY_2 = "passwordPolicy.defaultPolicy = ?";
1060    private static final String _FINDER_COLUMN_C_N_COMPANYID_2 = "passwordPolicy.companyId = ? AND ";
1061    private static final String _FINDER_COLUMN_C_N_NAME_1 = "passwordPolicy.name IS NULL";
1062    private static final String _FINDER_COLUMN_C_N_NAME_2 = "passwordPolicy.name = ?";
1063    private static final String _FINDER_COLUMN_C_N_NAME_3 = "(passwordPolicy.name IS NULL OR passwordPolicy.name = ?)";
1064    private static final String _ORDER_BY_ENTITY_ALIAS = "passwordPolicy.";
1065    private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No PasswordPolicy exists with the primary key ";
1066    private static final String _NO_SUCH_ENTITY_WITH_KEY = "No PasswordPolicy exists with the key {";
1067    private static Log _log = LogFactoryUtil.getLog(PasswordPolicyPersistenceImpl.class);
1068}