1   /**
2    * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
3    *
4    * The contents of this file are subject to the terms of the Liferay Enterprise
5    * Subscription License ("License"). You may not use this file except in
6    * compliance with the License. You can obtain a copy of the License by
7    * contacting Liferay, Inc. See the License for the specific language governing
8    * permissions and limitations under the License, including but not limited to
9    * distribution rights of the Software.
10   *
11   *
12   * 
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.SystemException;
20  import com.liferay.portal.kernel.annotation.BeanReference;
21  import com.liferay.portal.kernel.cache.CacheRegistry;
22  import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
23  import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
24  import com.liferay.portal.kernel.dao.orm.FinderPath;
25  import com.liferay.portal.kernel.dao.orm.Query;
26  import com.liferay.portal.kernel.dao.orm.QueryPos;
27  import com.liferay.portal.kernel.dao.orm.QueryUtil;
28  import com.liferay.portal.kernel.dao.orm.Session;
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     /**
243      * @deprecated Use {@link BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)}.
244      */
245     public PasswordPolicy update(PasswordPolicy passwordPolicy)
246         throws SystemException {
247         if (_log.isWarnEnabled()) {
248             _log.warn(
249                 "Using the deprecated update(PasswordPolicy passwordPolicy) method. Use update(PasswordPolicy passwordPolicy, boolean merge) instead.");
250         }
251 
252         return update(passwordPolicy, false);
253     }
254 
255     public PasswordPolicy updateImpl(
256         com.liferay.portal.model.PasswordPolicy passwordPolicy, boolean merge)
257         throws SystemException {
258         passwordPolicy = toUnwrappedModel(passwordPolicy);
259 
260         boolean isNew = passwordPolicy.isNew();
261 
262         PasswordPolicyModelImpl passwordPolicyModelImpl = (PasswordPolicyModelImpl)passwordPolicy;
263 
264         Session session = null;
265 
266         try {
267             session = openSession();
268 
269             BatchSessionUtil.update(session, passwordPolicy, merge);
270 
271             passwordPolicy.setNew(false);
272         }
273         catch (Exception e) {
274             throw processException(e);
275         }
276         finally {
277             closeSession(session);
278         }
279 
280         FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
281 
282         EntityCacheUtil.putResult(PasswordPolicyModelImpl.ENTITY_CACHE_ENABLED,
283             PasswordPolicyImpl.class, passwordPolicy.getPrimaryKey(),
284             passwordPolicy);
285 
286         if (!isNew &&
287                 ((passwordPolicy.getCompanyId() != passwordPolicyModelImpl.getOriginalCompanyId()) ||
288                 (passwordPolicy.getDefaultPolicy() != passwordPolicyModelImpl.getOriginalDefaultPolicy()))) {
289             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_DP,
290                 new Object[] {
291                     new Long(passwordPolicyModelImpl.getOriginalCompanyId()),
292                     Boolean.valueOf(
293                         passwordPolicyModelImpl.getOriginalDefaultPolicy())
294                 });
295         }
296 
297         if (isNew ||
298                 ((passwordPolicy.getCompanyId() != passwordPolicyModelImpl.getOriginalCompanyId()) ||
299                 (passwordPolicy.getDefaultPolicy() != passwordPolicyModelImpl.getOriginalDefaultPolicy()))) {
300             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_DP,
301                 new Object[] {
302                     new Long(passwordPolicy.getCompanyId()),
303                     Boolean.valueOf(passwordPolicy.getDefaultPolicy())
304                 }, passwordPolicy);
305         }
306 
307         if (!isNew &&
308                 ((passwordPolicy.getCompanyId() != passwordPolicyModelImpl.getOriginalCompanyId()) ||
309                 !Validator.equals(passwordPolicy.getName(),
310                     passwordPolicyModelImpl.getOriginalName()))) {
311             FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_N,
312                 new Object[] {
313                     new Long(passwordPolicyModelImpl.getOriginalCompanyId()),
314                     
315                 passwordPolicyModelImpl.getOriginalName()
316                 });
317         }
318 
319         if (isNew ||
320                 ((passwordPolicy.getCompanyId() != passwordPolicyModelImpl.getOriginalCompanyId()) ||
321                 !Validator.equals(passwordPolicy.getName(),
322                     passwordPolicyModelImpl.getOriginalName()))) {
323             FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_N,
324                 new Object[] {
325                     new Long(passwordPolicy.getCompanyId()),
326                     
327                 passwordPolicy.getName()
328                 }, passwordPolicy);
329         }
330 
331         return passwordPolicy;
332     }
333 
334     protected PasswordPolicy toUnwrappedModel(PasswordPolicy passwordPolicy) {
335         if (passwordPolicy instanceof PasswordPolicyImpl) {
336             return passwordPolicy;
337         }
338 
339         PasswordPolicyImpl passwordPolicyImpl = new PasswordPolicyImpl();
340 
341         passwordPolicyImpl.setNew(passwordPolicy.isNew());
342         passwordPolicyImpl.setPrimaryKey(passwordPolicy.getPrimaryKey());
343 
344         passwordPolicyImpl.setPasswordPolicyId(passwordPolicy.getPasswordPolicyId());
345         passwordPolicyImpl.setCompanyId(passwordPolicy.getCompanyId());
346         passwordPolicyImpl.setUserId(passwordPolicy.getUserId());
347         passwordPolicyImpl.setUserName(passwordPolicy.getUserName());
348         passwordPolicyImpl.setCreateDate(passwordPolicy.getCreateDate());
349         passwordPolicyImpl.setModifiedDate(passwordPolicy.getModifiedDate());
350         passwordPolicyImpl.setDefaultPolicy(passwordPolicy.isDefaultPolicy());
351         passwordPolicyImpl.setName(passwordPolicy.getName());
352         passwordPolicyImpl.setDescription(passwordPolicy.getDescription());
353         passwordPolicyImpl.setChangeable(passwordPolicy.isChangeable());
354         passwordPolicyImpl.setChangeRequired(passwordPolicy.isChangeRequired());
355         passwordPolicyImpl.setMinAge(passwordPolicy.getMinAge());
356         passwordPolicyImpl.setCheckSyntax(passwordPolicy.isCheckSyntax());
357         passwordPolicyImpl.setAllowDictionaryWords(passwordPolicy.isAllowDictionaryWords());
358         passwordPolicyImpl.setMinLength(passwordPolicy.getMinLength());
359         passwordPolicyImpl.setHistory(passwordPolicy.isHistory());
360         passwordPolicyImpl.setHistoryCount(passwordPolicy.getHistoryCount());
361         passwordPolicyImpl.setExpireable(passwordPolicy.isExpireable());
362         passwordPolicyImpl.setMaxAge(passwordPolicy.getMaxAge());
363         passwordPolicyImpl.setWarningTime(passwordPolicy.getWarningTime());
364         passwordPolicyImpl.setGraceLimit(passwordPolicy.getGraceLimit());
365         passwordPolicyImpl.setLockout(passwordPolicy.isLockout());
366         passwordPolicyImpl.setMaxFailure(passwordPolicy.getMaxFailure());
367         passwordPolicyImpl.setLockoutDuration(passwordPolicy.getLockoutDuration());
368         passwordPolicyImpl.setRequireUnlock(passwordPolicy.isRequireUnlock());
369         passwordPolicyImpl.setResetFailureCount(passwordPolicy.getResetFailureCount());
370 
371         return passwordPolicyImpl;
372     }
373 
374     public PasswordPolicy findByPrimaryKey(Serializable primaryKey)
375         throws NoSuchModelException, SystemException {
376         return findByPrimaryKey(((Long)primaryKey).longValue());
377     }
378 
379     public PasswordPolicy findByPrimaryKey(long passwordPolicyId)
380         throws NoSuchPasswordPolicyException, SystemException {
381         PasswordPolicy passwordPolicy = fetchByPrimaryKey(passwordPolicyId);
382 
383         if (passwordPolicy == null) {
384             if (_log.isWarnEnabled()) {
385                 _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + passwordPolicyId);
386             }
387 
388             throw new NoSuchPasswordPolicyException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
389                 passwordPolicyId);
390         }
391 
392         return passwordPolicy;
393     }
394 
395     public PasswordPolicy fetchByPrimaryKey(Serializable primaryKey)
396         throws SystemException {
397         return fetchByPrimaryKey(((Long)primaryKey).longValue());
398     }
399 
400     public PasswordPolicy fetchByPrimaryKey(long passwordPolicyId)
401         throws SystemException {
402         PasswordPolicy passwordPolicy = (PasswordPolicy)EntityCacheUtil.getResult(PasswordPolicyModelImpl.ENTITY_CACHE_ENABLED,
403                 PasswordPolicyImpl.class, passwordPolicyId, this);
404 
405         if (passwordPolicy == null) {
406             Session session = null;
407 
408             try {
409                 session = openSession();
410 
411                 passwordPolicy = (PasswordPolicy)session.get(PasswordPolicyImpl.class,
412                         new Long(passwordPolicyId));
413             }
414             catch (Exception e) {
415                 throw processException(e);
416             }
417             finally {
418                 if (passwordPolicy != null) {
419                     cacheResult(passwordPolicy);
420                 }
421 
422                 closeSession(session);
423             }
424         }
425 
426         return passwordPolicy;
427     }
428 
429     public PasswordPolicy findByC_DP(long companyId, boolean defaultPolicy)
430         throws NoSuchPasswordPolicyException, SystemException {
431         PasswordPolicy passwordPolicy = fetchByC_DP(companyId, defaultPolicy);
432 
433         if (passwordPolicy == null) {
434             StringBundler msg = new StringBundler(6);
435 
436             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
437 
438             msg.append("companyId=");
439             msg.append(companyId);
440 
441             msg.append(", defaultPolicy=");
442             msg.append(defaultPolicy);
443 
444             msg.append(StringPool.CLOSE_CURLY_BRACE);
445 
446             if (_log.isWarnEnabled()) {
447                 _log.warn(msg.toString());
448             }
449 
450             throw new NoSuchPasswordPolicyException(msg.toString());
451         }
452 
453         return passwordPolicy;
454     }
455 
456     public PasswordPolicy fetchByC_DP(long companyId, boolean defaultPolicy)
457         throws SystemException {
458         return fetchByC_DP(companyId, defaultPolicy, true);
459     }
460 
461     public PasswordPolicy fetchByC_DP(long companyId, boolean defaultPolicy,
462         boolean retrieveFromCache) throws SystemException {
463         Object[] finderArgs = new Object[] {
464                 new Long(companyId), Boolean.valueOf(defaultPolicy)
465             };
466 
467         Object result = null;
468 
469         if (retrieveFromCache) {
470             result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_C_DP,
471                     finderArgs, this);
472         }
473 
474         if (result == null) {
475             Session session = null;
476 
477             try {
478                 session = openSession();
479 
480                 StringBundler query = new StringBundler(3);
481 
482                 query.append(_SQL_SELECT_PASSWORDPOLICY_WHERE);
483 
484                 query.append(_FINDER_COLUMN_C_DP_COMPANYID_2);
485 
486                 query.append(_FINDER_COLUMN_C_DP_DEFAULTPOLICY_2);
487 
488                 String sql = query.toString();
489 
490                 Query q = session.createQuery(sql);
491 
492                 QueryPos qPos = QueryPos.getInstance(q);
493 
494                 qPos.add(companyId);
495 
496                 qPos.add(defaultPolicy);
497 
498                 List<PasswordPolicy> list = q.list();
499 
500                 result = list;
501 
502                 PasswordPolicy passwordPolicy = null;
503 
504                 if (list.isEmpty()) {
505                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_DP,
506                         finderArgs, list);
507                 }
508                 else {
509                     passwordPolicy = list.get(0);
510 
511                     cacheResult(passwordPolicy);
512 
513                     if ((passwordPolicy.getCompanyId() != companyId) ||
514                             (passwordPolicy.getDefaultPolicy() != defaultPolicy)) {
515                         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_DP,
516                             finderArgs, passwordPolicy);
517                     }
518                 }
519 
520                 return passwordPolicy;
521             }
522             catch (Exception e) {
523                 throw processException(e);
524             }
525             finally {
526                 if (result == null) {
527                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_DP,
528                         finderArgs, new ArrayList<PasswordPolicy>());
529                 }
530 
531                 closeSession(session);
532             }
533         }
534         else {
535             if (result instanceof List<?>) {
536                 return null;
537             }
538             else {
539                 return (PasswordPolicy)result;
540             }
541         }
542     }
543 
544     public PasswordPolicy findByC_N(long companyId, String name)
545         throws NoSuchPasswordPolicyException, SystemException {
546         PasswordPolicy passwordPolicy = fetchByC_N(companyId, name);
547 
548         if (passwordPolicy == null) {
549             StringBundler msg = new StringBundler(6);
550 
551             msg.append(_NO_SUCH_ENTITY_WITH_KEY);
552 
553             msg.append("companyId=");
554             msg.append(companyId);
555 
556             msg.append(", name=");
557             msg.append(name);
558 
559             msg.append(StringPool.CLOSE_CURLY_BRACE);
560 
561             if (_log.isWarnEnabled()) {
562                 _log.warn(msg.toString());
563             }
564 
565             throw new NoSuchPasswordPolicyException(msg.toString());
566         }
567 
568         return passwordPolicy;
569     }
570 
571     public PasswordPolicy fetchByC_N(long companyId, String name)
572         throws SystemException {
573         return fetchByC_N(companyId, name, true);
574     }
575 
576     public PasswordPolicy fetchByC_N(long companyId, String name,
577         boolean retrieveFromCache) throws SystemException {
578         Object[] finderArgs = new Object[] { new Long(companyId), name };
579 
580         Object result = null;
581 
582         if (retrieveFromCache) {
583             result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_C_N,
584                     finderArgs, this);
585         }
586 
587         if (result == null) {
588             Session session = null;
589 
590             try {
591                 session = openSession();
592 
593                 StringBundler query = new StringBundler(3);
594 
595                 query.append(_SQL_SELECT_PASSWORDPOLICY_WHERE);
596 
597                 query.append(_FINDER_COLUMN_C_N_COMPANYID_2);
598 
599                 if (name == null) {
600                     query.append(_FINDER_COLUMN_C_N_NAME_1);
601                 }
602                 else {
603                     if (name.equals(StringPool.BLANK)) {
604                         query.append(_FINDER_COLUMN_C_N_NAME_3);
605                     }
606                     else {
607                         query.append(_FINDER_COLUMN_C_N_NAME_2);
608                     }
609                 }
610 
611                 String sql = query.toString();
612 
613                 Query q = session.createQuery(sql);
614 
615                 QueryPos qPos = QueryPos.getInstance(q);
616 
617                 qPos.add(companyId);
618 
619                 if (name != null) {
620                     qPos.add(name);
621                 }
622 
623                 List<PasswordPolicy> list = q.list();
624 
625                 result = list;
626 
627                 PasswordPolicy passwordPolicy = null;
628 
629                 if (list.isEmpty()) {
630                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_N,
631                         finderArgs, list);
632                 }
633                 else {
634                     passwordPolicy = list.get(0);
635 
636                     cacheResult(passwordPolicy);
637 
638                     if ((passwordPolicy.getCompanyId() != companyId) ||
639                             (passwordPolicy.getName() == null) ||
640                             !passwordPolicy.getName().equals(name)) {
641                         FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_N,
642                             finderArgs, passwordPolicy);
643                     }
644                 }
645 
646                 return passwordPolicy;
647             }
648             catch (Exception e) {
649                 throw processException(e);
650             }
651             finally {
652                 if (result == null) {
653                     FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_N,
654                         finderArgs, new ArrayList<PasswordPolicy>());
655                 }
656 
657                 closeSession(session);
658             }
659         }
660         else {
661             if (result instanceof List<?>) {
662                 return null;
663             }
664             else {
665                 return (PasswordPolicy)result;
666             }
667         }
668     }
669 
670     public List<PasswordPolicy> findAll() throws SystemException {
671         return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
672     }
673 
674     public List<PasswordPolicy> findAll(int start, int end)
675         throws SystemException {
676         return findAll(start, end, null);
677     }
678 
679     public List<PasswordPolicy> findAll(int start, int end,
680         OrderByComparator orderByComparator) throws SystemException {
681         Object[] finderArgs = new Object[] {
682                 String.valueOf(start), String.valueOf(end),
683                 String.valueOf(orderByComparator)
684             };
685 
686         List<PasswordPolicy> list = (List<PasswordPolicy>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
687                 finderArgs, this);
688 
689         if (list == null) {
690             Session session = null;
691 
692             try {
693                 session = openSession();
694 
695                 StringBundler query = null;
696                 String sql = null;
697 
698                 if (orderByComparator != null) {
699                     query = new StringBundler(2 +
700                             (orderByComparator.getOrderByFields().length * 3));
701 
702                     query.append(_SQL_SELECT_PASSWORDPOLICY);
703 
704                     appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
705                         orderByComparator);
706 
707                     sql = query.toString();
708                 }
709 
710                 sql = _SQL_SELECT_PASSWORDPOLICY;
711 
712                 Query q = session.createQuery(sql);
713 
714                 if (orderByComparator == null) {
715                     list = (List<PasswordPolicy>)QueryUtil.list(q,
716                             getDialect(), start, end, false);
717 
718                     Collections.sort(list);
719                 }
720                 else {
721                     list = (List<PasswordPolicy>)QueryUtil.list(q,
722                             getDialect(), start, end);
723                 }
724             }
725             catch (Exception e) {
726                 throw processException(e);
727             }
728             finally {
729                 if (list == null) {
730                     list = new ArrayList<PasswordPolicy>();
731                 }
732 
733                 cacheResult(list);
734 
735                 FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
736 
737                 closeSession(session);
738             }
739         }
740 
741         return list;
742     }
743 
744     public void removeByC_DP(long companyId, boolean defaultPolicy)
745         throws NoSuchPasswordPolicyException, SystemException {
746         PasswordPolicy passwordPolicy = findByC_DP(companyId, defaultPolicy);
747 
748         remove(passwordPolicy);
749     }
750 
751     public void removeByC_N(long companyId, String name)
752         throws NoSuchPasswordPolicyException, SystemException {
753         PasswordPolicy passwordPolicy = findByC_N(companyId, name);
754 
755         remove(passwordPolicy);
756     }
757 
758     public void removeAll() throws SystemException {
759         for (PasswordPolicy passwordPolicy : findAll()) {
760             remove(passwordPolicy);
761         }
762     }
763 
764     public int countByC_DP(long companyId, boolean defaultPolicy)
765         throws SystemException {
766         Object[] finderArgs = new Object[] {
767                 new Long(companyId), Boolean.valueOf(defaultPolicy)
768             };
769 
770         Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_DP,
771                 finderArgs, this);
772 
773         if (count == null) {
774             Session session = null;
775 
776             try {
777                 session = openSession();
778 
779                 StringBundler query = new StringBundler(3);
780 
781                 query.append(_SQL_COUNT_PASSWORDPOLICY_WHERE);
782 
783                 query.append(_FINDER_COLUMN_C_DP_COMPANYID_2);
784 
785                 query.append(_FINDER_COLUMN_C_DP_DEFAULTPOLICY_2);
786 
787                 String sql = query.toString();
788 
789                 Query q = session.createQuery(sql);
790 
791                 QueryPos qPos = QueryPos.getInstance(q);
792 
793                 qPos.add(companyId);
794 
795                 qPos.add(defaultPolicy);
796 
797                 count = (Long)q.uniqueResult();
798             }
799             catch (Exception e) {
800                 throw processException(e);
801             }
802             finally {
803                 if (count == null) {
804                     count = Long.valueOf(0);
805                 }
806 
807                 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_DP,
808                     finderArgs, count);
809 
810                 closeSession(session);
811             }
812         }
813 
814         return count.intValue();
815     }
816 
817     public int countByC_N(long companyId, String name)
818         throws SystemException {
819         Object[] finderArgs = new Object[] { new Long(companyId), name };
820 
821         Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_N,
822                 finderArgs, this);
823 
824         if (count == null) {
825             Session session = null;
826 
827             try {
828                 session = openSession();
829 
830                 StringBundler query = new StringBundler(3);
831 
832                 query.append(_SQL_COUNT_PASSWORDPOLICY_WHERE);
833 
834                 query.append(_FINDER_COLUMN_C_N_COMPANYID_2);
835 
836                 if (name == null) {
837                     query.append(_FINDER_COLUMN_C_N_NAME_1);
838                 }
839                 else {
840                     if (name.equals(StringPool.BLANK)) {
841                         query.append(_FINDER_COLUMN_C_N_NAME_3);
842                     }
843                     else {
844                         query.append(_FINDER_COLUMN_C_N_NAME_2);
845                     }
846                 }
847 
848                 String sql = query.toString();
849 
850                 Query q = session.createQuery(sql);
851 
852                 QueryPos qPos = QueryPos.getInstance(q);
853 
854                 qPos.add(companyId);
855 
856                 if (name != null) {
857                     qPos.add(name);
858                 }
859 
860                 count = (Long)q.uniqueResult();
861             }
862             catch (Exception e) {
863                 throw processException(e);
864             }
865             finally {
866                 if (count == null) {
867                     count = Long.valueOf(0);
868                 }
869 
870                 FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_N, finderArgs,
871                     count);
872 
873                 closeSession(session);
874             }
875         }
876 
877         return count.intValue();
878     }
879 
880     public int countAll() throws SystemException {
881         Object[] finderArgs = new Object[0];
882 
883         Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
884                 finderArgs, this);
885 
886         if (count == null) {
887             Session session = null;
888 
889             try {
890                 session = openSession();
891 
892                 Query q = session.createQuery(_SQL_COUNT_PASSWORDPOLICY);
893 
894                 count = (Long)q.uniqueResult();
895             }
896             catch (Exception e) {
897                 throw processException(e);
898             }
899             finally {
900                 if (count == null) {
901                     count = Long.valueOf(0);
902                 }
903 
904                 FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
905                     count);
906 
907                 closeSession(session);
908             }
909         }
910 
911         return count.intValue();
912     }
913 
914     public void afterPropertiesSet() {
915         String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
916                     com.liferay.portal.util.PropsUtil.get(
917                         "value.object.listener.com.liferay.portal.model.PasswordPolicy")));
918 
919         if (listenerClassNames.length > 0) {
920             try {
921                 List<ModelListener<PasswordPolicy>> listenersList = new ArrayList<ModelListener<PasswordPolicy>>();
922 
923                 for (String listenerClassName : listenerClassNames) {
924                     listenersList.add((ModelListener<PasswordPolicy>)Class.forName(
925                             listenerClassName).newInstance());
926                 }
927 
928                 listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
929             }
930             catch (Exception e) {
931                 _log.error(e);
932             }
933         }
934     }
935 
936     @BeanReference(type = AccountPersistence.class)
937     protected AccountPersistence accountPersistence;
938     @BeanReference(type = AddressPersistence.class)
939     protected AddressPersistence addressPersistence;
940     @BeanReference(type = BrowserTrackerPersistence.class)
941     protected BrowserTrackerPersistence browserTrackerPersistence;
942     @BeanReference(type = ClassNamePersistence.class)
943     protected ClassNamePersistence classNamePersistence;
944     @BeanReference(type = CompanyPersistence.class)
945     protected CompanyPersistence companyPersistence;
946     @BeanReference(type = ContactPersistence.class)
947     protected ContactPersistence contactPersistence;
948     @BeanReference(type = CountryPersistence.class)
949     protected CountryPersistence countryPersistence;
950     @BeanReference(type = EmailAddressPersistence.class)
951     protected EmailAddressPersistence emailAddressPersistence;
952     @BeanReference(type = GroupPersistence.class)
953     protected GroupPersistence groupPersistence;
954     @BeanReference(type = ImagePersistence.class)
955     protected ImagePersistence imagePersistence;
956     @BeanReference(type = LayoutPersistence.class)
957     protected LayoutPersistence layoutPersistence;
958     @BeanReference(type = LayoutSetPersistence.class)
959     protected LayoutSetPersistence layoutSetPersistence;
960     @BeanReference(type = ListTypePersistence.class)
961     protected ListTypePersistence listTypePersistence;
962     @BeanReference(type = LockPersistence.class)
963     protected LockPersistence lockPersistence;
964     @BeanReference(type = MembershipRequestPersistence.class)
965     protected MembershipRequestPersistence membershipRequestPersistence;
966     @BeanReference(type = OrganizationPersistence.class)
967     protected OrganizationPersistence organizationPersistence;
968     @BeanReference(type = OrgGroupPermissionPersistence.class)
969     protected OrgGroupPermissionPersistence orgGroupPermissionPersistence;
970     @BeanReference(type = OrgGroupRolePersistence.class)
971     protected OrgGroupRolePersistence orgGroupRolePersistence;
972     @BeanReference(type = OrgLaborPersistence.class)
973     protected OrgLaborPersistence orgLaborPersistence;
974     @BeanReference(type = PasswordPolicyPersistence.class)
975     protected PasswordPolicyPersistence passwordPolicyPersistence;
976     @BeanReference(type = PasswordPolicyRelPersistence.class)
977     protected PasswordPolicyRelPersistence passwordPolicyRelPersistence;
978     @BeanReference(type = PasswordTrackerPersistence.class)
979     protected PasswordTrackerPersistence passwordTrackerPersistence;
980     @BeanReference(type = PermissionPersistence.class)
981     protected PermissionPersistence permissionPersistence;
982     @BeanReference(type = PhonePersistence.class)
983     protected PhonePersistence phonePersistence;
984     @BeanReference(type = PluginSettingPersistence.class)
985     protected PluginSettingPersistence pluginSettingPersistence;
986     @BeanReference(type = PortletPersistence.class)
987     protected PortletPersistence portletPersistence;
988     @BeanReference(type = PortletItemPersistence.class)
989     protected PortletItemPersistence portletItemPersistence;
990     @BeanReference(type = PortletPreferencesPersistence.class)
991     protected PortletPreferencesPersistence portletPreferencesPersistence;
992     @BeanReference(type = RegionPersistence.class)
993     protected RegionPersistence regionPersistence;
994     @BeanReference(type = ReleasePersistence.class)
995     protected ReleasePersistence releasePersistence;
996     @BeanReference(type = ResourcePersistence.class)
997     protected ResourcePersistence resourcePersistence;
998     @BeanReference(type = ResourceActionPersistence.class)
999     protected ResourceActionPersistence resourceActionPersistence;
1000    @BeanReference(type = ResourceCodePersistence.class)
1001    protected ResourceCodePersistence resourceCodePersistence;
1002    @BeanReference(type = ResourcePermissionPersistence.class)
1003    protected ResourcePermissionPersistence resourcePermissionPersistence;
1004    @BeanReference(type = RolePersistence.class)
1005    protected RolePersistence rolePersistence;
1006    @BeanReference(type = ServiceComponentPersistence.class)
1007    protected ServiceComponentPersistence serviceComponentPersistence;
1008    @BeanReference(type = ShardPersistence.class)
1009    protected ShardPersistence shardPersistence;
1010    @BeanReference(type = SubscriptionPersistence.class)
1011    protected SubscriptionPersistence subscriptionPersistence;
1012    @BeanReference(type = UserPersistence.class)
1013    protected UserPersistence userPersistence;
1014    @BeanReference(type = UserGroupPersistence.class)
1015    protected UserGroupPersistence userGroupPersistence;
1016    @BeanReference(type = UserGroupGroupRolePersistence.class)
1017    protected UserGroupGroupRolePersistence userGroupGroupRolePersistence;
1018    @BeanReference(type = UserGroupRolePersistence.class)
1019    protected UserGroupRolePersistence userGroupRolePersistence;
1020    @BeanReference(type = UserIdMapperPersistence.class)
1021    protected UserIdMapperPersistence userIdMapperPersistence;
1022    @BeanReference(type = UserTrackerPersistence.class)
1023    protected UserTrackerPersistence userTrackerPersistence;
1024    @BeanReference(type = UserTrackerPathPersistence.class)
1025    protected UserTrackerPathPersistence userTrackerPathPersistence;
1026    @BeanReference(type = WebDAVPropsPersistence.class)
1027    protected WebDAVPropsPersistence webDAVPropsPersistence;
1028    @BeanReference(type = WebsitePersistence.class)
1029    protected WebsitePersistence websitePersistence;
1030    private static final String _SQL_SELECT_PASSWORDPOLICY = "SELECT passwordPolicy FROM PasswordPolicy passwordPolicy";
1031    private static final String _SQL_SELECT_PASSWORDPOLICY_WHERE = "SELECT passwordPolicy FROM PasswordPolicy passwordPolicy WHERE ";
1032    private static final String _SQL_COUNT_PASSWORDPOLICY = "SELECT COUNT(passwordPolicy) FROM PasswordPolicy passwordPolicy";
1033    private static final String _SQL_COUNT_PASSWORDPOLICY_WHERE = "SELECT COUNT(passwordPolicy) FROM PasswordPolicy passwordPolicy WHERE ";
1034    private static final String _FINDER_COLUMN_C_DP_COMPANYID_2 = "passwordPolicy.companyId = ? AND ";
1035    private static final String _FINDER_COLUMN_C_DP_DEFAULTPOLICY_2 = "passwordPolicy.defaultPolicy = ?";
1036    private static final String _FINDER_COLUMN_C_N_COMPANYID_2 = "passwordPolicy.companyId = ? AND ";
1037    private static final String _FINDER_COLUMN_C_N_NAME_1 = "passwordPolicy.name IS NULL";
1038    private static final String _FINDER_COLUMN_C_N_NAME_2 = "passwordPolicy.name = ?";
1039    private static final String _FINDER_COLUMN_C_N_NAME_3 = "(passwordPolicy.name IS NULL OR passwordPolicy.name = ?)";
1040    private static final String _ORDER_BY_ENTITY_ALIAS = "passwordPolicy.";
1041    private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No PasswordPolicy exists with the primary key ";
1042    private static final String _NO_SUCH_ENTITY_WITH_KEY = "No PasswordPolicy exists with the key {";
1043    private static Log _log = LogFactoryUtil.getLog(PasswordPolicyPersistenceImpl.class);
1044}