001    /**
002     * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portal.service.persistence;
016    
017    import com.liferay.portal.NoSuchModelException;
018    import com.liferay.portal.NoSuchPasswordPolicyException;
019    import com.liferay.portal.kernel.annotation.BeanReference;
020    import com.liferay.portal.kernel.cache.CacheRegistryUtil;
021    import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
022    import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
023    import com.liferay.portal.kernel.dao.orm.FinderPath;
024    import com.liferay.portal.kernel.dao.orm.Query;
025    import com.liferay.portal.kernel.dao.orm.QueryPos;
026    import com.liferay.portal.kernel.dao.orm.QueryUtil;
027    import com.liferay.portal.kernel.dao.orm.Session;
028    import com.liferay.portal.kernel.exception.SystemException;
029    import com.liferay.portal.kernel.log.Log;
030    import com.liferay.portal.kernel.log.LogFactoryUtil;
031    import com.liferay.portal.kernel.util.GetterUtil;
032    import com.liferay.portal.kernel.util.InstanceFactory;
033    import com.liferay.portal.kernel.util.OrderByComparator;
034    import com.liferay.portal.kernel.util.StringBundler;
035    import com.liferay.portal.kernel.util.StringPool;
036    import com.liferay.portal.kernel.util.StringUtil;
037    import com.liferay.portal.kernel.util.Validator;
038    import com.liferay.portal.model.ModelListener;
039    import com.liferay.portal.model.PasswordPolicy;
040    import com.liferay.portal.model.impl.PasswordPolicyImpl;
041    import com.liferay.portal.model.impl.PasswordPolicyModelImpl;
042    import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
043    
044    import java.io.Serializable;
045    
046    import java.util.ArrayList;
047    import java.util.Collections;
048    import java.util.List;
049    
050    /**
051     * @author    Brian Wing Shun Chan
052     * @see       PasswordPolicyPersistence
053     * @see       PasswordPolicyUtil
054     * @generated
055     */
056    public class PasswordPolicyPersistenceImpl extends BasePersistenceImpl<PasswordPolicy>
057            implements PasswordPolicyPersistence {
058            public static final String FINDER_CLASS_NAME_ENTITY = PasswordPolicyImpl.class.getName();
059            public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
060                    ".List";
061            public static final FinderPath FINDER_PATH_FETCH_BY_C_DP = new FinderPath(PasswordPolicyModelImpl.ENTITY_CACHE_ENABLED,
062                            PasswordPolicyModelImpl.FINDER_CACHE_ENABLED,
063                            FINDER_CLASS_NAME_ENTITY, "fetchByC_DP",
064                            new String[] { Long.class.getName(), Boolean.class.getName() });
065            public static final FinderPath FINDER_PATH_COUNT_BY_C_DP = new FinderPath(PasswordPolicyModelImpl.ENTITY_CACHE_ENABLED,
066                            PasswordPolicyModelImpl.FINDER_CACHE_ENABLED,
067                            FINDER_CLASS_NAME_LIST, "countByC_DP",
068                            new String[] { Long.class.getName(), Boolean.class.getName() });
069            public static final FinderPath FINDER_PATH_FETCH_BY_C_N = new FinderPath(PasswordPolicyModelImpl.ENTITY_CACHE_ENABLED,
070                            PasswordPolicyModelImpl.FINDER_CACHE_ENABLED,
071                            FINDER_CLASS_NAME_ENTITY, "fetchByC_N",
072                            new String[] { Long.class.getName(), String.class.getName() });
073            public static final FinderPath FINDER_PATH_COUNT_BY_C_N = new FinderPath(PasswordPolicyModelImpl.ENTITY_CACHE_ENABLED,
074                            PasswordPolicyModelImpl.FINDER_CACHE_ENABLED,
075                            FINDER_CLASS_NAME_LIST, "countByC_N",
076                            new String[] { Long.class.getName(), String.class.getName() });
077            public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(PasswordPolicyModelImpl.ENTITY_CACHE_ENABLED,
078                            PasswordPolicyModelImpl.FINDER_CACHE_ENABLED,
079                            FINDER_CLASS_NAME_LIST, "findAll", new String[0]);
080            public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(PasswordPolicyModelImpl.ENTITY_CACHE_ENABLED,
081                            PasswordPolicyModelImpl.FINDER_CACHE_ENABLED,
082                            FINDER_CLASS_NAME_LIST, "countAll", new String[0]);
083    
084            public void cacheResult(PasswordPolicy passwordPolicy) {
085                    EntityCacheUtil.putResult(PasswordPolicyModelImpl.ENTITY_CACHE_ENABLED,
086                            PasswordPolicyImpl.class, passwordPolicy.getPrimaryKey(),
087                            passwordPolicy);
088    
089                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_DP,
090                            new Object[] {
091                                    new Long(passwordPolicy.getCompanyId()),
092                                    Boolean.valueOf(passwordPolicy.getDefaultPolicy())
093                            }, passwordPolicy);
094    
095                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_N,
096                            new Object[] {
097                                    new Long(passwordPolicy.getCompanyId()),
098                                    
099                            passwordPolicy.getName()
100                            }, passwordPolicy);
101            }
102    
103            public void cacheResult(List<PasswordPolicy> passwordPolicies) {
104                    for (PasswordPolicy passwordPolicy : passwordPolicies) {
105                            if (EntityCacheUtil.getResult(
106                                                    PasswordPolicyModelImpl.ENTITY_CACHE_ENABLED,
107                                                    PasswordPolicyImpl.class,
108                                                    passwordPolicy.getPrimaryKey(), this) == null) {
109                                    cacheResult(passwordPolicy);
110                            }
111                    }
112            }
113    
114            public void clearCache() {
115                    CacheRegistryUtil.clear(PasswordPolicyImpl.class.getName());
116                    EntityCacheUtil.clearCache(PasswordPolicyImpl.class.getName());
117                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
118                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
119            }
120    
121            public void clearCache(PasswordPolicy passwordPolicy) {
122                    EntityCacheUtil.removeResult(PasswordPolicyModelImpl.ENTITY_CACHE_ENABLED,
123                            PasswordPolicyImpl.class, passwordPolicy.getPrimaryKey());
124    
125                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_DP,
126                            new Object[] {
127                                    new Long(passwordPolicy.getCompanyId()),
128                                    Boolean.valueOf(passwordPolicy.getDefaultPolicy())
129                            });
130    
131                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_N,
132                            new Object[] {
133                                    new Long(passwordPolicy.getCompanyId()),
134                                    
135                            passwordPolicy.getName()
136                            });
137            }
138    
139            public PasswordPolicy create(long passwordPolicyId) {
140                    PasswordPolicy passwordPolicy = new PasswordPolicyImpl();
141    
142                    passwordPolicy.setNew(true);
143                    passwordPolicy.setPrimaryKey(passwordPolicyId);
144    
145                    return passwordPolicy;
146            }
147    
148            public PasswordPolicy remove(Serializable primaryKey)
149                    throws NoSuchModelException, SystemException {
150                    return remove(((Long)primaryKey).longValue());
151            }
152    
153            public PasswordPolicy remove(long passwordPolicyId)
154                    throws NoSuchPasswordPolicyException, SystemException {
155                    Session session = null;
156    
157                    try {
158                            session = openSession();
159    
160                            PasswordPolicy passwordPolicy = (PasswordPolicy)session.get(PasswordPolicyImpl.class,
161                                            new Long(passwordPolicyId));
162    
163                            if (passwordPolicy == null) {
164                                    if (_log.isWarnEnabled()) {
165                                            _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
166                                                    passwordPolicyId);
167                                    }
168    
169                                    throw new NoSuchPasswordPolicyException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
170                                            passwordPolicyId);
171                            }
172    
173                            return remove(passwordPolicy);
174                    }
175                    catch (NoSuchPasswordPolicyException nsee) {
176                            throw nsee;
177                    }
178                    catch (Exception e) {
179                            throw processException(e);
180                    }
181                    finally {
182                            closeSession(session);
183                    }
184            }
185    
186            protected PasswordPolicy removeImpl(PasswordPolicy passwordPolicy)
187                    throws SystemException {
188                    passwordPolicy = toUnwrappedModel(passwordPolicy);
189    
190                    Session session = null;
191    
192                    try {
193                            session = openSession();
194    
195                            if (passwordPolicy.isCachedModel() || BatchSessionUtil.isEnabled()) {
196                                    Object staleObject = session.get(PasswordPolicyImpl.class,
197                                                    passwordPolicy.getPrimaryKeyObj());
198    
199                                    if (staleObject != null) {
200                                            session.evict(staleObject);
201                                    }
202                            }
203    
204                            session.delete(passwordPolicy);
205    
206                            session.flush();
207                    }
208                    catch (Exception e) {
209                            throw processException(e);
210                    }
211                    finally {
212                            closeSession(session);
213                    }
214    
215                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
216    
217                    PasswordPolicyModelImpl passwordPolicyModelImpl = (PasswordPolicyModelImpl)passwordPolicy;
218    
219                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_DP,
220                            new Object[] {
221                                    new Long(passwordPolicyModelImpl.getOriginalCompanyId()),
222                                    Boolean.valueOf(
223                                            passwordPolicyModelImpl.getOriginalDefaultPolicy())
224                            });
225    
226                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_N,
227                            new Object[] {
228                                    new Long(passwordPolicyModelImpl.getOriginalCompanyId()),
229                                    
230                            passwordPolicyModelImpl.getOriginalName()
231                            });
232    
233                    EntityCacheUtil.removeResult(PasswordPolicyModelImpl.ENTITY_CACHE_ENABLED,
234                            PasswordPolicyImpl.class, passwordPolicy.getPrimaryKey());
235    
236                    return passwordPolicy;
237            }
238    
239            public PasswordPolicy updateImpl(
240                    com.liferay.portal.model.PasswordPolicy passwordPolicy, boolean merge)
241                    throws SystemException {
242                    passwordPolicy = toUnwrappedModel(passwordPolicy);
243    
244                    boolean isNew = passwordPolicy.isNew();
245    
246                    PasswordPolicyModelImpl passwordPolicyModelImpl = (PasswordPolicyModelImpl)passwordPolicy;
247    
248                    Session session = null;
249    
250                    try {
251                            session = openSession();
252    
253                            BatchSessionUtil.update(session, passwordPolicy, merge);
254    
255                            passwordPolicy.setNew(false);
256                    }
257                    catch (Exception e) {
258                            throw processException(e);
259                    }
260                    finally {
261                            closeSession(session);
262                    }
263    
264                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
265    
266                    EntityCacheUtil.putResult(PasswordPolicyModelImpl.ENTITY_CACHE_ENABLED,
267                            PasswordPolicyImpl.class, passwordPolicy.getPrimaryKey(),
268                            passwordPolicy);
269    
270                    if (!isNew &&
271                                    ((passwordPolicy.getCompanyId() != passwordPolicyModelImpl.getOriginalCompanyId()) ||
272                                    (passwordPolicy.getDefaultPolicy() != passwordPolicyModelImpl.getOriginalDefaultPolicy()))) {
273                            FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_DP,
274                                    new Object[] {
275                                            new Long(passwordPolicyModelImpl.getOriginalCompanyId()),
276                                            Boolean.valueOf(
277                                                    passwordPolicyModelImpl.getOriginalDefaultPolicy())
278                                    });
279                    }
280    
281                    if (isNew ||
282                                    ((passwordPolicy.getCompanyId() != passwordPolicyModelImpl.getOriginalCompanyId()) ||
283                                    (passwordPolicy.getDefaultPolicy() != passwordPolicyModelImpl.getOriginalDefaultPolicy()))) {
284                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_DP,
285                                    new Object[] {
286                                            new Long(passwordPolicy.getCompanyId()),
287                                            Boolean.valueOf(passwordPolicy.getDefaultPolicy())
288                                    }, passwordPolicy);
289                    }
290    
291                    if (!isNew &&
292                                    ((passwordPolicy.getCompanyId() != passwordPolicyModelImpl.getOriginalCompanyId()) ||
293                                    !Validator.equals(passwordPolicy.getName(),
294                                            passwordPolicyModelImpl.getOriginalName()))) {
295                            FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_N,
296                                    new Object[] {
297                                            new Long(passwordPolicyModelImpl.getOriginalCompanyId()),
298                                            
299                                    passwordPolicyModelImpl.getOriginalName()
300                                    });
301                    }
302    
303                    if (isNew ||
304                                    ((passwordPolicy.getCompanyId() != passwordPolicyModelImpl.getOriginalCompanyId()) ||
305                                    !Validator.equals(passwordPolicy.getName(),
306                                            passwordPolicyModelImpl.getOriginalName()))) {
307                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_N,
308                                    new Object[] {
309                                            new Long(passwordPolicy.getCompanyId()),
310                                            
311                                    passwordPolicy.getName()
312                                    }, passwordPolicy);
313                    }
314    
315                    return passwordPolicy;
316            }
317    
318            protected PasswordPolicy toUnwrappedModel(PasswordPolicy passwordPolicy) {
319                    if (passwordPolicy instanceof PasswordPolicyImpl) {
320                            return passwordPolicy;
321                    }
322    
323                    PasswordPolicyImpl passwordPolicyImpl = new PasswordPolicyImpl();
324    
325                    passwordPolicyImpl.setNew(passwordPolicy.isNew());
326                    passwordPolicyImpl.setPrimaryKey(passwordPolicy.getPrimaryKey());
327    
328                    passwordPolicyImpl.setPasswordPolicyId(passwordPolicy.getPasswordPolicyId());
329                    passwordPolicyImpl.setCompanyId(passwordPolicy.getCompanyId());
330                    passwordPolicyImpl.setUserId(passwordPolicy.getUserId());
331                    passwordPolicyImpl.setUserName(passwordPolicy.getUserName());
332                    passwordPolicyImpl.setCreateDate(passwordPolicy.getCreateDate());
333                    passwordPolicyImpl.setModifiedDate(passwordPolicy.getModifiedDate());
334                    passwordPolicyImpl.setDefaultPolicy(passwordPolicy.isDefaultPolicy());
335                    passwordPolicyImpl.setName(passwordPolicy.getName());
336                    passwordPolicyImpl.setDescription(passwordPolicy.getDescription());
337                    passwordPolicyImpl.setChangeable(passwordPolicy.isChangeable());
338                    passwordPolicyImpl.setChangeRequired(passwordPolicy.isChangeRequired());
339                    passwordPolicyImpl.setMinAge(passwordPolicy.getMinAge());
340                    passwordPolicyImpl.setCheckSyntax(passwordPolicy.isCheckSyntax());
341                    passwordPolicyImpl.setAllowDictionaryWords(passwordPolicy.isAllowDictionaryWords());
342                    passwordPolicyImpl.setMinAlphanumeric(passwordPolicy.getMinAlphanumeric());
343                    passwordPolicyImpl.setMinLength(passwordPolicy.getMinLength());
344                    passwordPolicyImpl.setMinLowerCase(passwordPolicy.getMinLowerCase());
345                    passwordPolicyImpl.setMinNumbers(passwordPolicy.getMinNumbers());
346                    passwordPolicyImpl.setMinSymbols(passwordPolicy.getMinSymbols());
347                    passwordPolicyImpl.setMinUpperCase(passwordPolicy.getMinUpperCase());
348                    passwordPolicyImpl.setHistory(passwordPolicy.isHistory());
349                    passwordPolicyImpl.setHistoryCount(passwordPolicy.getHistoryCount());
350                    passwordPolicyImpl.setExpireable(passwordPolicy.isExpireable());
351                    passwordPolicyImpl.setMaxAge(passwordPolicy.getMaxAge());
352                    passwordPolicyImpl.setWarningTime(passwordPolicy.getWarningTime());
353                    passwordPolicyImpl.setGraceLimit(passwordPolicy.getGraceLimit());
354                    passwordPolicyImpl.setLockout(passwordPolicy.isLockout());
355                    passwordPolicyImpl.setMaxFailure(passwordPolicy.getMaxFailure());
356                    passwordPolicyImpl.setLockoutDuration(passwordPolicy.getLockoutDuration());
357                    passwordPolicyImpl.setRequireUnlock(passwordPolicy.isRequireUnlock());
358                    passwordPolicyImpl.setResetFailureCount(passwordPolicy.getResetFailureCount());
359                    passwordPolicyImpl.setResetTicketMaxAge(passwordPolicy.getResetTicketMaxAge());
360    
361                    return passwordPolicyImpl;
362            }
363    
364            public PasswordPolicy findByPrimaryKey(Serializable primaryKey)
365                    throws NoSuchModelException, SystemException {
366                    return findByPrimaryKey(((Long)primaryKey).longValue());
367            }
368    
369            public PasswordPolicy findByPrimaryKey(long passwordPolicyId)
370                    throws NoSuchPasswordPolicyException, SystemException {
371                    PasswordPolicy passwordPolicy = fetchByPrimaryKey(passwordPolicyId);
372    
373                    if (passwordPolicy == null) {
374                            if (_log.isWarnEnabled()) {
375                                    _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + passwordPolicyId);
376                            }
377    
378                            throw new NoSuchPasswordPolicyException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
379                                    passwordPolicyId);
380                    }
381    
382                    return passwordPolicy;
383            }
384    
385            public PasswordPolicy fetchByPrimaryKey(Serializable primaryKey)
386                    throws SystemException {
387                    return fetchByPrimaryKey(((Long)primaryKey).longValue());
388            }
389    
390            public PasswordPolicy fetchByPrimaryKey(long passwordPolicyId)
391                    throws SystemException {
392                    PasswordPolicy passwordPolicy = (PasswordPolicy)EntityCacheUtil.getResult(PasswordPolicyModelImpl.ENTITY_CACHE_ENABLED,
393                                    PasswordPolicyImpl.class, passwordPolicyId, this);
394    
395                    if (passwordPolicy == null) {
396                            Session session = null;
397    
398                            try {
399                                    session = openSession();
400    
401                                    passwordPolicy = (PasswordPolicy)session.get(PasswordPolicyImpl.class,
402                                                    new Long(passwordPolicyId));
403                            }
404                            catch (Exception e) {
405                                    throw processException(e);
406                            }
407                            finally {
408                                    if (passwordPolicy != null) {
409                                            cacheResult(passwordPolicy);
410                                    }
411    
412                                    closeSession(session);
413                            }
414                    }
415    
416                    return passwordPolicy;
417            }
418    
419            public PasswordPolicy findByC_DP(long companyId, boolean defaultPolicy)
420                    throws NoSuchPasswordPolicyException, SystemException {
421                    PasswordPolicy passwordPolicy = fetchByC_DP(companyId, defaultPolicy);
422    
423                    if (passwordPolicy == null) {
424                            StringBundler msg = new StringBundler(6);
425    
426                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
427    
428                            msg.append("companyId=");
429                            msg.append(companyId);
430    
431                            msg.append(", defaultPolicy=");
432                            msg.append(defaultPolicy);
433    
434                            msg.append(StringPool.CLOSE_CURLY_BRACE);
435    
436                            if (_log.isWarnEnabled()) {
437                                    _log.warn(msg.toString());
438                            }
439    
440                            throw new NoSuchPasswordPolicyException(msg.toString());
441                    }
442    
443                    return passwordPolicy;
444            }
445    
446            public PasswordPolicy fetchByC_DP(long companyId, boolean defaultPolicy)
447                    throws SystemException {
448                    return fetchByC_DP(companyId, defaultPolicy, true);
449            }
450    
451            public PasswordPolicy fetchByC_DP(long companyId, boolean defaultPolicy,
452                    boolean retrieveFromCache) throws SystemException {
453                    Object[] finderArgs = new Object[] { companyId, defaultPolicy };
454    
455                    Object result = null;
456    
457                    if (retrieveFromCache) {
458                            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_C_DP,
459                                            finderArgs, this);
460                    }
461    
462                    if (result == null) {
463                            Session session = null;
464    
465                            try {
466                                    session = openSession();
467    
468                                    StringBundler query = new StringBundler(3);
469    
470                                    query.append(_SQL_SELECT_PASSWORDPOLICY_WHERE);
471    
472                                    query.append(_FINDER_COLUMN_C_DP_COMPANYID_2);
473    
474                                    query.append(_FINDER_COLUMN_C_DP_DEFAULTPOLICY_2);
475    
476                                    String sql = query.toString();
477    
478                                    Query q = session.createQuery(sql);
479    
480                                    QueryPos qPos = QueryPos.getInstance(q);
481    
482                                    qPos.add(companyId);
483    
484                                    qPos.add(defaultPolicy);
485    
486                                    List<PasswordPolicy> list = q.list();
487    
488                                    result = list;
489    
490                                    PasswordPolicy passwordPolicy = null;
491    
492                                    if (list.isEmpty()) {
493                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_DP,
494                                                    finderArgs, list);
495                                    }
496                                    else {
497                                            passwordPolicy = list.get(0);
498    
499                                            cacheResult(passwordPolicy);
500    
501                                            if ((passwordPolicy.getCompanyId() != companyId) ||
502                                                            (passwordPolicy.getDefaultPolicy() != defaultPolicy)) {
503                                                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_DP,
504                                                            finderArgs, passwordPolicy);
505                                            }
506                                    }
507    
508                                    return passwordPolicy;
509                            }
510                            catch (Exception e) {
511                                    throw processException(e);
512                            }
513                            finally {
514                                    if (result == null) {
515                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_DP,
516                                                    finderArgs, new ArrayList<PasswordPolicy>());
517                                    }
518    
519                                    closeSession(session);
520                            }
521                    }
522                    else {
523                            if (result instanceof List<?>) {
524                                    return null;
525                            }
526                            else {
527                                    return (PasswordPolicy)result;
528                            }
529                    }
530            }
531    
532            public PasswordPolicy findByC_N(long companyId, String name)
533                    throws NoSuchPasswordPolicyException, SystemException {
534                    PasswordPolicy passwordPolicy = fetchByC_N(companyId, name);
535    
536                    if (passwordPolicy == null) {
537                            StringBundler msg = new StringBundler(6);
538    
539                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
540    
541                            msg.append("companyId=");
542                            msg.append(companyId);
543    
544                            msg.append(", name=");
545                            msg.append(name);
546    
547                            msg.append(StringPool.CLOSE_CURLY_BRACE);
548    
549                            if (_log.isWarnEnabled()) {
550                                    _log.warn(msg.toString());
551                            }
552    
553                            throw new NoSuchPasswordPolicyException(msg.toString());
554                    }
555    
556                    return passwordPolicy;
557            }
558    
559            public PasswordPolicy fetchByC_N(long companyId, String name)
560                    throws SystemException {
561                    return fetchByC_N(companyId, name, true);
562            }
563    
564            public PasswordPolicy fetchByC_N(long companyId, String name,
565                    boolean retrieveFromCache) throws SystemException {
566                    Object[] finderArgs = new Object[] { companyId, name };
567    
568                    Object result = null;
569    
570                    if (retrieveFromCache) {
571                            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_C_N,
572                                            finderArgs, this);
573                    }
574    
575                    if (result == null) {
576                            Session session = null;
577    
578                            try {
579                                    session = openSession();
580    
581                                    StringBundler query = new StringBundler(3);
582    
583                                    query.append(_SQL_SELECT_PASSWORDPOLICY_WHERE);
584    
585                                    query.append(_FINDER_COLUMN_C_N_COMPANYID_2);
586    
587                                    if (name == null) {
588                                            query.append(_FINDER_COLUMN_C_N_NAME_1);
589                                    }
590                                    else {
591                                            if (name.equals(StringPool.BLANK)) {
592                                                    query.append(_FINDER_COLUMN_C_N_NAME_3);
593                                            }
594                                            else {
595                                                    query.append(_FINDER_COLUMN_C_N_NAME_2);
596                                            }
597                                    }
598    
599                                    String sql = query.toString();
600    
601                                    Query q = session.createQuery(sql);
602    
603                                    QueryPos qPos = QueryPos.getInstance(q);
604    
605                                    qPos.add(companyId);
606    
607                                    if (name != null) {
608                                            qPos.add(name);
609                                    }
610    
611                                    List<PasswordPolicy> list = q.list();
612    
613                                    result = list;
614    
615                                    PasswordPolicy passwordPolicy = null;
616    
617                                    if (list.isEmpty()) {
618                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_N,
619                                                    finderArgs, list);
620                                    }
621                                    else {
622                                            passwordPolicy = list.get(0);
623    
624                                            cacheResult(passwordPolicy);
625    
626                                            if ((passwordPolicy.getCompanyId() != companyId) ||
627                                                            (passwordPolicy.getName() == null) ||
628                                                            !passwordPolicy.getName().equals(name)) {
629                                                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_N,
630                                                            finderArgs, passwordPolicy);
631                                            }
632                                    }
633    
634                                    return passwordPolicy;
635                            }
636                            catch (Exception e) {
637                                    throw processException(e);
638                            }
639                            finally {
640                                    if (result == null) {
641                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_N,
642                                                    finderArgs, new ArrayList<PasswordPolicy>());
643                                    }
644    
645                                    closeSession(session);
646                            }
647                    }
648                    else {
649                            if (result instanceof List<?>) {
650                                    return null;
651                            }
652                            else {
653                                    return (PasswordPolicy)result;
654                            }
655                    }
656            }
657    
658            public List<PasswordPolicy> findAll() throws SystemException {
659                    return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
660            }
661    
662            public List<PasswordPolicy> findAll(int start, int end)
663                    throws SystemException {
664                    return findAll(start, end, null);
665            }
666    
667            public List<PasswordPolicy> findAll(int start, int end,
668                    OrderByComparator orderByComparator) throws SystemException {
669                    Object[] finderArgs = new Object[] {
670                                    String.valueOf(start), String.valueOf(end),
671                                    String.valueOf(orderByComparator)
672                            };
673    
674                    List<PasswordPolicy> list = (List<PasswordPolicy>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
675                                    finderArgs, this);
676    
677                    if (list == null) {
678                            Session session = null;
679    
680                            try {
681                                    session = openSession();
682    
683                                    StringBundler query = null;
684                                    String sql = null;
685    
686                                    if (orderByComparator != null) {
687                                            query = new StringBundler(2 +
688                                                            (orderByComparator.getOrderByFields().length * 3));
689    
690                                            query.append(_SQL_SELECT_PASSWORDPOLICY);
691    
692                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
693                                                    orderByComparator);
694    
695                                            sql = query.toString();
696                                    }
697                                    else {
698                                            sql = _SQL_SELECT_PASSWORDPOLICY;
699                                    }
700    
701                                    Query q = session.createQuery(sql);
702    
703                                    if (orderByComparator == null) {
704                                            list = (List<PasswordPolicy>)QueryUtil.list(q,
705                                                            getDialect(), start, end, false);
706    
707                                            Collections.sort(list);
708                                    }
709                                    else {
710                                            list = (List<PasswordPolicy>)QueryUtil.list(q,
711                                                            getDialect(), start, end);
712                                    }
713                            }
714                            catch (Exception e) {
715                                    throw processException(e);
716                            }
717                            finally {
718                                    if (list == null) {
719                                            list = new ArrayList<PasswordPolicy>();
720                                    }
721    
722                                    cacheResult(list);
723    
724                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
725    
726                                    closeSession(session);
727                            }
728                    }
729    
730                    return list;
731            }
732    
733            public void removeByC_DP(long companyId, boolean defaultPolicy)
734                    throws NoSuchPasswordPolicyException, SystemException {
735                    PasswordPolicy passwordPolicy = findByC_DP(companyId, defaultPolicy);
736    
737                    remove(passwordPolicy);
738            }
739    
740            public void removeByC_N(long companyId, String name)
741                    throws NoSuchPasswordPolicyException, SystemException {
742                    PasswordPolicy passwordPolicy = findByC_N(companyId, name);
743    
744                    remove(passwordPolicy);
745            }
746    
747            public void removeAll() throws SystemException {
748                    for (PasswordPolicy passwordPolicy : findAll()) {
749                            remove(passwordPolicy);
750                    }
751            }
752    
753            public int countByC_DP(long companyId, boolean defaultPolicy)
754                    throws SystemException {
755                    Object[] finderArgs = new Object[] { companyId, defaultPolicy };
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[] { 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>)InstanceFactory.newInstance(
912                                                            listenerClassName));
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 = TicketPersistence.class)
1004            protected TicketPersistence ticketPersistence;
1005            @BeanReference(type = TeamPersistence.class)
1006            protected TeamPersistence teamPersistence;
1007            @BeanReference(type = UserPersistence.class)
1008            protected UserPersistence userPersistence;
1009            @BeanReference(type = UserGroupPersistence.class)
1010            protected UserGroupPersistence userGroupPersistence;
1011            @BeanReference(type = UserGroupGroupRolePersistence.class)
1012            protected UserGroupGroupRolePersistence userGroupGroupRolePersistence;
1013            @BeanReference(type = UserGroupRolePersistence.class)
1014            protected UserGroupRolePersistence userGroupRolePersistence;
1015            @BeanReference(type = UserIdMapperPersistence.class)
1016            protected UserIdMapperPersistence userIdMapperPersistence;
1017            @BeanReference(type = UserTrackerPersistence.class)
1018            protected UserTrackerPersistence userTrackerPersistence;
1019            @BeanReference(type = UserTrackerPathPersistence.class)
1020            protected UserTrackerPathPersistence userTrackerPathPersistence;
1021            @BeanReference(type = WebDAVPropsPersistence.class)
1022            protected WebDAVPropsPersistence webDAVPropsPersistence;
1023            @BeanReference(type = WebsitePersistence.class)
1024            protected WebsitePersistence websitePersistence;
1025            @BeanReference(type = WorkflowDefinitionLinkPersistence.class)
1026            protected WorkflowDefinitionLinkPersistence workflowDefinitionLinkPersistence;
1027            @BeanReference(type = WorkflowInstanceLinkPersistence.class)
1028            protected WorkflowInstanceLinkPersistence workflowInstanceLinkPersistence;
1029            private static final String _SQL_SELECT_PASSWORDPOLICY = "SELECT passwordPolicy FROM PasswordPolicy passwordPolicy";
1030            private static final String _SQL_SELECT_PASSWORDPOLICY_WHERE = "SELECT passwordPolicy FROM PasswordPolicy passwordPolicy WHERE ";
1031            private static final String _SQL_COUNT_PASSWORDPOLICY = "SELECT COUNT(passwordPolicy) FROM PasswordPolicy passwordPolicy";
1032            private static final String _SQL_COUNT_PASSWORDPOLICY_WHERE = "SELECT COUNT(passwordPolicy) FROM PasswordPolicy passwordPolicy WHERE ";
1033            private static final String _FINDER_COLUMN_C_DP_COMPANYID_2 = "passwordPolicy.companyId = ? AND ";
1034            private static final String _FINDER_COLUMN_C_DP_DEFAULTPOLICY_2 = "passwordPolicy.defaultPolicy = ?";
1035            private static final String _FINDER_COLUMN_C_N_COMPANYID_2 = "passwordPolicy.companyId = ? AND ";
1036            private static final String _FINDER_COLUMN_C_N_NAME_1 = "passwordPolicy.name IS NULL";
1037            private static final String _FINDER_COLUMN_C_N_NAME_2 = "passwordPolicy.name = ?";
1038            private static final String _FINDER_COLUMN_C_N_NAME_3 = "(passwordPolicy.name IS NULL OR passwordPolicy.name = ?)";
1039            private static final String _ORDER_BY_ENTITY_ALIAS = "passwordPolicy.";
1040            private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No PasswordPolicy exists with the primary key ";
1041            private static final String _NO_SUCH_ENTITY_WITH_KEY = "No PasswordPolicy exists with the key {";
1042            private static Log _log = LogFactoryUtil.getLog(PasswordPolicyPersistenceImpl.class);
1043    }