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