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.NoSuchPasswordPolicyRelException;
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.model.ModelListener;
038    import com.liferay.portal.model.PasswordPolicyRel;
039    import com.liferay.portal.model.impl.PasswordPolicyRelImpl;
040    import com.liferay.portal.model.impl.PasswordPolicyRelModelImpl;
041    import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
042    
043    import java.io.Serializable;
044    
045    import java.util.ArrayList;
046    import java.util.Collections;
047    import java.util.List;
048    
049    /**
050     * @author    Brian Wing Shun Chan
051     * @see       PasswordPolicyRelPersistence
052     * @see       PasswordPolicyRelUtil
053     * @generated
054     */
055    public class PasswordPolicyRelPersistenceImpl extends BasePersistenceImpl<PasswordPolicyRel>
056            implements PasswordPolicyRelPersistence {
057            public static final String FINDER_CLASS_NAME_ENTITY = PasswordPolicyRelImpl.class.getName();
058            public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
059                    ".List";
060            public static final FinderPath FINDER_PATH_FIND_BY_PASSWORDPOLICYID = new FinderPath(PasswordPolicyRelModelImpl.ENTITY_CACHE_ENABLED,
061                            PasswordPolicyRelModelImpl.FINDER_CACHE_ENABLED,
062                            FINDER_CLASS_NAME_LIST, "findByPasswordPolicyId",
063                            new String[] {
064                                    Long.class.getName(),
065                                    
066                            "java.lang.Integer", "java.lang.Integer",
067                                    "com.liferay.portal.kernel.util.OrderByComparator"
068                            });
069            public static final FinderPath FINDER_PATH_COUNT_BY_PASSWORDPOLICYID = new FinderPath(PasswordPolicyRelModelImpl.ENTITY_CACHE_ENABLED,
070                            PasswordPolicyRelModelImpl.FINDER_CACHE_ENABLED,
071                            FINDER_CLASS_NAME_LIST, "countByPasswordPolicyId",
072                            new String[] { Long.class.getName() });
073            public static final FinderPath FINDER_PATH_FETCH_BY_C_C = new FinderPath(PasswordPolicyRelModelImpl.ENTITY_CACHE_ENABLED,
074                            PasswordPolicyRelModelImpl.FINDER_CACHE_ENABLED,
075                            FINDER_CLASS_NAME_ENTITY, "fetchByC_C",
076                            new String[] { Long.class.getName(), Long.class.getName() });
077            public static final FinderPath FINDER_PATH_COUNT_BY_C_C = new FinderPath(PasswordPolicyRelModelImpl.ENTITY_CACHE_ENABLED,
078                            PasswordPolicyRelModelImpl.FINDER_CACHE_ENABLED,
079                            FINDER_CLASS_NAME_LIST, "countByC_C",
080                            new String[] { Long.class.getName(), Long.class.getName() });
081            public static final FinderPath FINDER_PATH_FETCH_BY_P_C_C = new FinderPath(PasswordPolicyRelModelImpl.ENTITY_CACHE_ENABLED,
082                            PasswordPolicyRelModelImpl.FINDER_CACHE_ENABLED,
083                            FINDER_CLASS_NAME_ENTITY, "fetchByP_C_C",
084                            new String[] {
085                                    Long.class.getName(), Long.class.getName(), Long.class.getName()
086                            });
087            public static final FinderPath FINDER_PATH_COUNT_BY_P_C_C = new FinderPath(PasswordPolicyRelModelImpl.ENTITY_CACHE_ENABLED,
088                            PasswordPolicyRelModelImpl.FINDER_CACHE_ENABLED,
089                            FINDER_CLASS_NAME_LIST, "countByP_C_C",
090                            new String[] {
091                                    Long.class.getName(), Long.class.getName(), Long.class.getName()
092                            });
093            public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(PasswordPolicyRelModelImpl.ENTITY_CACHE_ENABLED,
094                            PasswordPolicyRelModelImpl.FINDER_CACHE_ENABLED,
095                            FINDER_CLASS_NAME_LIST, "findAll", new String[0]);
096            public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(PasswordPolicyRelModelImpl.ENTITY_CACHE_ENABLED,
097                            PasswordPolicyRelModelImpl.FINDER_CACHE_ENABLED,
098                            FINDER_CLASS_NAME_LIST, "countAll", new String[0]);
099    
100            public void cacheResult(PasswordPolicyRel passwordPolicyRel) {
101                    EntityCacheUtil.putResult(PasswordPolicyRelModelImpl.ENTITY_CACHE_ENABLED,
102                            PasswordPolicyRelImpl.class, passwordPolicyRel.getPrimaryKey(),
103                            passwordPolicyRel);
104    
105                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_C,
106                            new Object[] {
107                                    new Long(passwordPolicyRel.getClassNameId()),
108                                    new Long(passwordPolicyRel.getClassPK())
109                            }, passwordPolicyRel);
110    
111                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_P_C_C,
112                            new Object[] {
113                                    new Long(passwordPolicyRel.getPasswordPolicyId()),
114                                    new Long(passwordPolicyRel.getClassNameId()),
115                                    new Long(passwordPolicyRel.getClassPK())
116                            }, passwordPolicyRel);
117            }
118    
119            public void cacheResult(List<PasswordPolicyRel> passwordPolicyRels) {
120                    for (PasswordPolicyRel passwordPolicyRel : passwordPolicyRels) {
121                            if (EntityCacheUtil.getResult(
122                                                    PasswordPolicyRelModelImpl.ENTITY_CACHE_ENABLED,
123                                                    PasswordPolicyRelImpl.class,
124                                                    passwordPolicyRel.getPrimaryKey(), this) == null) {
125                                    cacheResult(passwordPolicyRel);
126                            }
127                    }
128            }
129    
130            public void clearCache() {
131                    CacheRegistryUtil.clear(PasswordPolicyRelImpl.class.getName());
132                    EntityCacheUtil.clearCache(PasswordPolicyRelImpl.class.getName());
133                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
134                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
135            }
136    
137            public void clearCache(PasswordPolicyRel passwordPolicyRel) {
138                    EntityCacheUtil.removeResult(PasswordPolicyRelModelImpl.ENTITY_CACHE_ENABLED,
139                            PasswordPolicyRelImpl.class, passwordPolicyRel.getPrimaryKey());
140    
141                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_C,
142                            new Object[] {
143                                    new Long(passwordPolicyRel.getClassNameId()),
144                                    new Long(passwordPolicyRel.getClassPK())
145                            });
146    
147                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_P_C_C,
148                            new Object[] {
149                                    new Long(passwordPolicyRel.getPasswordPolicyId()),
150                                    new Long(passwordPolicyRel.getClassNameId()),
151                                    new Long(passwordPolicyRel.getClassPK())
152                            });
153            }
154    
155            public PasswordPolicyRel create(long passwordPolicyRelId) {
156                    PasswordPolicyRel passwordPolicyRel = new PasswordPolicyRelImpl();
157    
158                    passwordPolicyRel.setNew(true);
159                    passwordPolicyRel.setPrimaryKey(passwordPolicyRelId);
160    
161                    return passwordPolicyRel;
162            }
163    
164            public PasswordPolicyRel remove(Serializable primaryKey)
165                    throws NoSuchModelException, SystemException {
166                    return remove(((Long)primaryKey).longValue());
167            }
168    
169            public PasswordPolicyRel remove(long passwordPolicyRelId)
170                    throws NoSuchPasswordPolicyRelException, SystemException {
171                    Session session = null;
172    
173                    try {
174                            session = openSession();
175    
176                            PasswordPolicyRel passwordPolicyRel = (PasswordPolicyRel)session.get(PasswordPolicyRelImpl.class,
177                                            new Long(passwordPolicyRelId));
178    
179                            if (passwordPolicyRel == null) {
180                                    if (_log.isWarnEnabled()) {
181                                            _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
182                                                    passwordPolicyRelId);
183                                    }
184    
185                                    throw new NoSuchPasswordPolicyRelException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
186                                            passwordPolicyRelId);
187                            }
188    
189                            return remove(passwordPolicyRel);
190                    }
191                    catch (NoSuchPasswordPolicyRelException nsee) {
192                            throw nsee;
193                    }
194                    catch (Exception e) {
195                            throw processException(e);
196                    }
197                    finally {
198                            closeSession(session);
199                    }
200            }
201    
202            protected PasswordPolicyRel removeImpl(PasswordPolicyRel passwordPolicyRel)
203                    throws SystemException {
204                    passwordPolicyRel = toUnwrappedModel(passwordPolicyRel);
205    
206                    Session session = null;
207    
208                    try {
209                            session = openSession();
210    
211                            if (passwordPolicyRel.isCachedModel() ||
212                                            BatchSessionUtil.isEnabled()) {
213                                    Object staleObject = session.get(PasswordPolicyRelImpl.class,
214                                                    passwordPolicyRel.getPrimaryKeyObj());
215    
216                                    if (staleObject != null) {
217                                            session.evict(staleObject);
218                                    }
219                            }
220    
221                            session.delete(passwordPolicyRel);
222    
223                            session.flush();
224                    }
225                    catch (Exception e) {
226                            throw processException(e);
227                    }
228                    finally {
229                            closeSession(session);
230                    }
231    
232                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
233    
234                    PasswordPolicyRelModelImpl passwordPolicyRelModelImpl = (PasswordPolicyRelModelImpl)passwordPolicyRel;
235    
236                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_C,
237                            new Object[] {
238                                    new Long(passwordPolicyRelModelImpl.getOriginalClassNameId()),
239                                    new Long(passwordPolicyRelModelImpl.getOriginalClassPK())
240                            });
241    
242                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_P_C_C,
243                            new Object[] {
244                                    new Long(passwordPolicyRelModelImpl.getOriginalPasswordPolicyId()),
245                                    new Long(passwordPolicyRelModelImpl.getOriginalClassNameId()),
246                                    new Long(passwordPolicyRelModelImpl.getOriginalClassPK())
247                            });
248    
249                    EntityCacheUtil.removeResult(PasswordPolicyRelModelImpl.ENTITY_CACHE_ENABLED,
250                            PasswordPolicyRelImpl.class, passwordPolicyRel.getPrimaryKey());
251    
252                    return passwordPolicyRel;
253            }
254    
255            public PasswordPolicyRel updateImpl(
256                    com.liferay.portal.model.PasswordPolicyRel passwordPolicyRel,
257                    boolean merge) throws SystemException {
258                    passwordPolicyRel = toUnwrappedModel(passwordPolicyRel);
259    
260                    boolean isNew = passwordPolicyRel.isNew();
261    
262                    PasswordPolicyRelModelImpl passwordPolicyRelModelImpl = (PasswordPolicyRelModelImpl)passwordPolicyRel;
263    
264                    Session session = null;
265    
266                    try {
267                            session = openSession();
268    
269                            BatchSessionUtil.update(session, passwordPolicyRel, merge);
270    
271                            passwordPolicyRel.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(PasswordPolicyRelModelImpl.ENTITY_CACHE_ENABLED,
283                            PasswordPolicyRelImpl.class, passwordPolicyRel.getPrimaryKey(),
284                            passwordPolicyRel);
285    
286                    if (!isNew &&
287                                    ((passwordPolicyRel.getClassNameId() != passwordPolicyRelModelImpl.getOriginalClassNameId()) ||
288                                    (passwordPolicyRel.getClassPK() != passwordPolicyRelModelImpl.getOriginalClassPK()))) {
289                            FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_C_C,
290                                    new Object[] {
291                                            new Long(passwordPolicyRelModelImpl.getOriginalClassNameId()),
292                                            new Long(passwordPolicyRelModelImpl.getOriginalClassPK())
293                                    });
294                    }
295    
296                    if (isNew ||
297                                    ((passwordPolicyRel.getClassNameId() != passwordPolicyRelModelImpl.getOriginalClassNameId()) ||
298                                    (passwordPolicyRel.getClassPK() != passwordPolicyRelModelImpl.getOriginalClassPK()))) {
299                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_C,
300                                    new Object[] {
301                                            new Long(passwordPolicyRel.getClassNameId()),
302                                            new Long(passwordPolicyRel.getClassPK())
303                                    }, passwordPolicyRel);
304                    }
305    
306                    if (!isNew &&
307                                    ((passwordPolicyRel.getPasswordPolicyId() != passwordPolicyRelModelImpl.getOriginalPasswordPolicyId()) ||
308                                    (passwordPolicyRel.getClassNameId() != passwordPolicyRelModelImpl.getOriginalClassNameId()) ||
309                                    (passwordPolicyRel.getClassPK() != passwordPolicyRelModelImpl.getOriginalClassPK()))) {
310                            FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_P_C_C,
311                                    new Object[] {
312                                            new Long(passwordPolicyRelModelImpl.getOriginalPasswordPolicyId()),
313                                            new Long(passwordPolicyRelModelImpl.getOriginalClassNameId()),
314                                            new Long(passwordPolicyRelModelImpl.getOriginalClassPK())
315                                    });
316                    }
317    
318                    if (isNew ||
319                                    ((passwordPolicyRel.getPasswordPolicyId() != passwordPolicyRelModelImpl.getOriginalPasswordPolicyId()) ||
320                                    (passwordPolicyRel.getClassNameId() != passwordPolicyRelModelImpl.getOriginalClassNameId()) ||
321                                    (passwordPolicyRel.getClassPK() != passwordPolicyRelModelImpl.getOriginalClassPK()))) {
322                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_P_C_C,
323                                    new Object[] {
324                                            new Long(passwordPolicyRel.getPasswordPolicyId()),
325                                            new Long(passwordPolicyRel.getClassNameId()),
326                                            new Long(passwordPolicyRel.getClassPK())
327                                    }, passwordPolicyRel);
328                    }
329    
330                    return passwordPolicyRel;
331            }
332    
333            protected PasswordPolicyRel toUnwrappedModel(
334                    PasswordPolicyRel passwordPolicyRel) {
335                    if (passwordPolicyRel instanceof PasswordPolicyRelImpl) {
336                            return passwordPolicyRel;
337                    }
338    
339                    PasswordPolicyRelImpl passwordPolicyRelImpl = new PasswordPolicyRelImpl();
340    
341                    passwordPolicyRelImpl.setNew(passwordPolicyRel.isNew());
342                    passwordPolicyRelImpl.setPrimaryKey(passwordPolicyRel.getPrimaryKey());
343    
344                    passwordPolicyRelImpl.setPasswordPolicyRelId(passwordPolicyRel.getPasswordPolicyRelId());
345                    passwordPolicyRelImpl.setPasswordPolicyId(passwordPolicyRel.getPasswordPolicyId());
346                    passwordPolicyRelImpl.setClassNameId(passwordPolicyRel.getClassNameId());
347                    passwordPolicyRelImpl.setClassPK(passwordPolicyRel.getClassPK());
348    
349                    return passwordPolicyRelImpl;
350            }
351    
352            public PasswordPolicyRel findByPrimaryKey(Serializable primaryKey)
353                    throws NoSuchModelException, SystemException {
354                    return findByPrimaryKey(((Long)primaryKey).longValue());
355            }
356    
357            public PasswordPolicyRel findByPrimaryKey(long passwordPolicyRelId)
358                    throws NoSuchPasswordPolicyRelException, SystemException {
359                    PasswordPolicyRel passwordPolicyRel = fetchByPrimaryKey(passwordPolicyRelId);
360    
361                    if (passwordPolicyRel == null) {
362                            if (_log.isWarnEnabled()) {
363                                    _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
364                                            passwordPolicyRelId);
365                            }
366    
367                            throw new NoSuchPasswordPolicyRelException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
368                                    passwordPolicyRelId);
369                    }
370    
371                    return passwordPolicyRel;
372            }
373    
374            public PasswordPolicyRel fetchByPrimaryKey(Serializable primaryKey)
375                    throws SystemException {
376                    return fetchByPrimaryKey(((Long)primaryKey).longValue());
377            }
378    
379            public PasswordPolicyRel fetchByPrimaryKey(long passwordPolicyRelId)
380                    throws SystemException {
381                    PasswordPolicyRel passwordPolicyRel = (PasswordPolicyRel)EntityCacheUtil.getResult(PasswordPolicyRelModelImpl.ENTITY_CACHE_ENABLED,
382                                    PasswordPolicyRelImpl.class, passwordPolicyRelId, this);
383    
384                    if (passwordPolicyRel == null) {
385                            Session session = null;
386    
387                            try {
388                                    session = openSession();
389    
390                                    passwordPolicyRel = (PasswordPolicyRel)session.get(PasswordPolicyRelImpl.class,
391                                                    new Long(passwordPolicyRelId));
392                            }
393                            catch (Exception e) {
394                                    throw processException(e);
395                            }
396                            finally {
397                                    if (passwordPolicyRel != null) {
398                                            cacheResult(passwordPolicyRel);
399                                    }
400    
401                                    closeSession(session);
402                            }
403                    }
404    
405                    return passwordPolicyRel;
406            }
407    
408            public List<PasswordPolicyRel> findByPasswordPolicyId(long passwordPolicyId)
409                    throws SystemException {
410                    return findByPasswordPolicyId(passwordPolicyId, QueryUtil.ALL_POS,
411                            QueryUtil.ALL_POS, null);
412            }
413    
414            public List<PasswordPolicyRel> findByPasswordPolicyId(
415                    long passwordPolicyId, int start, int end) throws SystemException {
416                    return findByPasswordPolicyId(passwordPolicyId, start, end, null);
417            }
418    
419            public List<PasswordPolicyRel> findByPasswordPolicyId(
420                    long passwordPolicyId, int start, int end,
421                    OrderByComparator orderByComparator) throws SystemException {
422                    Object[] finderArgs = new Object[] {
423                                    passwordPolicyId,
424                                    
425                                    String.valueOf(start), String.valueOf(end),
426                                    String.valueOf(orderByComparator)
427                            };
428    
429                    List<PasswordPolicyRel> list = (List<PasswordPolicyRel>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_PASSWORDPOLICYID,
430                                    finderArgs, this);
431    
432                    if (list == null) {
433                            Session session = null;
434    
435                            try {
436                                    session = openSession();
437    
438                                    StringBundler query = null;
439    
440                                    if (orderByComparator != null) {
441                                            query = new StringBundler(3 +
442                                                            (orderByComparator.getOrderByFields().length * 3));
443                                    }
444                                    else {
445                                            query = new StringBundler(2);
446                                    }
447    
448                                    query.append(_SQL_SELECT_PASSWORDPOLICYREL_WHERE);
449    
450                                    query.append(_FINDER_COLUMN_PASSWORDPOLICYID_PASSWORDPOLICYID_2);
451    
452                                    if (orderByComparator != null) {
453                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
454                                                    orderByComparator);
455                                    }
456    
457                                    String sql = query.toString();
458    
459                                    Query q = session.createQuery(sql);
460    
461                                    QueryPos qPos = QueryPos.getInstance(q);
462    
463                                    qPos.add(passwordPolicyId);
464    
465                                    list = (List<PasswordPolicyRel>)QueryUtil.list(q, getDialect(),
466                                                    start, end);
467                            }
468                            catch (Exception e) {
469                                    throw processException(e);
470                            }
471                            finally {
472                                    if (list == null) {
473                                            list = new ArrayList<PasswordPolicyRel>();
474                                    }
475    
476                                    cacheResult(list);
477    
478                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_PASSWORDPOLICYID,
479                                            finderArgs, list);
480    
481                                    closeSession(session);
482                            }
483                    }
484    
485                    return list;
486            }
487    
488            public PasswordPolicyRel findByPasswordPolicyId_First(
489                    long passwordPolicyId, OrderByComparator orderByComparator)
490                    throws NoSuchPasswordPolicyRelException, SystemException {
491                    List<PasswordPolicyRel> list = findByPasswordPolicyId(passwordPolicyId,
492                                    0, 1, orderByComparator);
493    
494                    if (list.isEmpty()) {
495                            StringBundler msg = new StringBundler(4);
496    
497                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
498    
499                            msg.append("passwordPolicyId=");
500                            msg.append(passwordPolicyId);
501    
502                            msg.append(StringPool.CLOSE_CURLY_BRACE);
503    
504                            throw new NoSuchPasswordPolicyRelException(msg.toString());
505                    }
506                    else {
507                            return list.get(0);
508                    }
509            }
510    
511            public PasswordPolicyRel findByPasswordPolicyId_Last(
512                    long passwordPolicyId, OrderByComparator orderByComparator)
513                    throws NoSuchPasswordPolicyRelException, SystemException {
514                    int count = countByPasswordPolicyId(passwordPolicyId);
515    
516                    List<PasswordPolicyRel> list = findByPasswordPolicyId(passwordPolicyId,
517                                    count - 1, count, orderByComparator);
518    
519                    if (list.isEmpty()) {
520                            StringBundler msg = new StringBundler(4);
521    
522                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
523    
524                            msg.append("passwordPolicyId=");
525                            msg.append(passwordPolicyId);
526    
527                            msg.append(StringPool.CLOSE_CURLY_BRACE);
528    
529                            throw new NoSuchPasswordPolicyRelException(msg.toString());
530                    }
531                    else {
532                            return list.get(0);
533                    }
534            }
535    
536            public PasswordPolicyRel[] findByPasswordPolicyId_PrevAndNext(
537                    long passwordPolicyRelId, long passwordPolicyId,
538                    OrderByComparator orderByComparator)
539                    throws NoSuchPasswordPolicyRelException, SystemException {
540                    PasswordPolicyRel passwordPolicyRel = findByPrimaryKey(passwordPolicyRelId);
541    
542                    Session session = null;
543    
544                    try {
545                            session = openSession();
546    
547                            PasswordPolicyRel[] array = new PasswordPolicyRelImpl[3];
548    
549                            array[0] = getByPasswordPolicyId_PrevAndNext(session,
550                                            passwordPolicyRel, passwordPolicyId, orderByComparator, true);
551    
552                            array[1] = passwordPolicyRel;
553    
554                            array[2] = getByPasswordPolicyId_PrevAndNext(session,
555                                            passwordPolicyRel, passwordPolicyId, orderByComparator,
556                                            false);
557    
558                            return array;
559                    }
560                    catch (Exception e) {
561                            throw processException(e);
562                    }
563                    finally {
564                            closeSession(session);
565                    }
566            }
567    
568            protected PasswordPolicyRel getByPasswordPolicyId_PrevAndNext(
569                    Session session, PasswordPolicyRel passwordPolicyRel,
570                    long passwordPolicyId, OrderByComparator orderByComparator,
571                    boolean previous) {
572                    StringBundler query = null;
573    
574                    if (orderByComparator != null) {
575                            query = new StringBundler(6 +
576                                            (orderByComparator.getOrderByFields().length * 6));
577                    }
578                    else {
579                            query = new StringBundler(3);
580                    }
581    
582                    query.append(_SQL_SELECT_PASSWORDPOLICYREL_WHERE);
583    
584                    query.append(_FINDER_COLUMN_PASSWORDPOLICYID_PASSWORDPOLICYID_2);
585    
586                    if (orderByComparator != null) {
587                            String[] orderByFields = orderByComparator.getOrderByFields();
588    
589                            if (orderByFields.length > 0) {
590                                    query.append(WHERE_AND);
591                            }
592    
593                            for (int i = 0; i < orderByFields.length; i++) {
594                                    query.append(_ORDER_BY_ENTITY_ALIAS);
595                                    query.append(orderByFields[i]);
596    
597                                    if ((i + 1) < orderByFields.length) {
598                                            if (orderByComparator.isAscending() ^ previous) {
599                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
600                                            }
601                                            else {
602                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
603                                            }
604                                    }
605                                    else {
606                                            if (orderByComparator.isAscending() ^ previous) {
607                                                    query.append(WHERE_GREATER_THAN);
608                                            }
609                                            else {
610                                                    query.append(WHERE_LESSER_THAN);
611                                            }
612                                    }
613                            }
614    
615                            query.append(ORDER_BY_CLAUSE);
616    
617                            for (int i = 0; i < orderByFields.length; i++) {
618                                    query.append(_ORDER_BY_ENTITY_ALIAS);
619                                    query.append(orderByFields[i]);
620    
621                                    if ((i + 1) < orderByFields.length) {
622                                            if (orderByComparator.isAscending() ^ previous) {
623                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
624                                            }
625                                            else {
626                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
627                                            }
628                                    }
629                                    else {
630                                            if (orderByComparator.isAscending() ^ previous) {
631                                                    query.append(ORDER_BY_ASC);
632                                            }
633                                            else {
634                                                    query.append(ORDER_BY_DESC);
635                                            }
636                                    }
637                            }
638                    }
639    
640                    String sql = query.toString();
641    
642                    Query q = session.createQuery(sql);
643    
644                    q.setFirstResult(0);
645                    q.setMaxResults(2);
646    
647                    QueryPos qPos = QueryPos.getInstance(q);
648    
649                    qPos.add(passwordPolicyId);
650    
651                    if (orderByComparator != null) {
652                            Object[] values = orderByComparator.getOrderByValues(passwordPolicyRel);
653    
654                            for (Object value : values) {
655                                    qPos.add(value);
656                            }
657                    }
658    
659                    List<PasswordPolicyRel> list = q.list();
660    
661                    if (list.size() == 2) {
662                            return list.get(1);
663                    }
664                    else {
665                            return null;
666                    }
667            }
668    
669            public PasswordPolicyRel findByC_C(long classNameId, long classPK)
670                    throws NoSuchPasswordPolicyRelException, SystemException {
671                    PasswordPolicyRel passwordPolicyRel = fetchByC_C(classNameId, classPK);
672    
673                    if (passwordPolicyRel == null) {
674                            StringBundler msg = new StringBundler(6);
675    
676                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
677    
678                            msg.append("classNameId=");
679                            msg.append(classNameId);
680    
681                            msg.append(", classPK=");
682                            msg.append(classPK);
683    
684                            msg.append(StringPool.CLOSE_CURLY_BRACE);
685    
686                            if (_log.isWarnEnabled()) {
687                                    _log.warn(msg.toString());
688                            }
689    
690                            throw new NoSuchPasswordPolicyRelException(msg.toString());
691                    }
692    
693                    return passwordPolicyRel;
694            }
695    
696            public PasswordPolicyRel fetchByC_C(long classNameId, long classPK)
697                    throws SystemException {
698                    return fetchByC_C(classNameId, classPK, true);
699            }
700    
701            public PasswordPolicyRel fetchByC_C(long classNameId, long classPK,
702                    boolean retrieveFromCache) throws SystemException {
703                    Object[] finderArgs = new Object[] { classNameId, classPK };
704    
705                    Object result = null;
706    
707                    if (retrieveFromCache) {
708                            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_C_C,
709                                            finderArgs, this);
710                    }
711    
712                    if (result == null) {
713                            Session session = null;
714    
715                            try {
716                                    session = openSession();
717    
718                                    StringBundler query = new StringBundler(3);
719    
720                                    query.append(_SQL_SELECT_PASSWORDPOLICYREL_WHERE);
721    
722                                    query.append(_FINDER_COLUMN_C_C_CLASSNAMEID_2);
723    
724                                    query.append(_FINDER_COLUMN_C_C_CLASSPK_2);
725    
726                                    String sql = query.toString();
727    
728                                    Query q = session.createQuery(sql);
729    
730                                    QueryPos qPos = QueryPos.getInstance(q);
731    
732                                    qPos.add(classNameId);
733    
734                                    qPos.add(classPK);
735    
736                                    List<PasswordPolicyRel> list = q.list();
737    
738                                    result = list;
739    
740                                    PasswordPolicyRel passwordPolicyRel = null;
741    
742                                    if (list.isEmpty()) {
743                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_C,
744                                                    finderArgs, list);
745                                    }
746                                    else {
747                                            passwordPolicyRel = list.get(0);
748    
749                                            cacheResult(passwordPolicyRel);
750    
751                                            if ((passwordPolicyRel.getClassNameId() != classNameId) ||
752                                                            (passwordPolicyRel.getClassPK() != classPK)) {
753                                                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_C,
754                                                            finderArgs, passwordPolicyRel);
755                                            }
756                                    }
757    
758                                    return passwordPolicyRel;
759                            }
760                            catch (Exception e) {
761                                    throw processException(e);
762                            }
763                            finally {
764                                    if (result == null) {
765                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_C_C,
766                                                    finderArgs, new ArrayList<PasswordPolicyRel>());
767                                    }
768    
769                                    closeSession(session);
770                            }
771                    }
772                    else {
773                            if (result instanceof List<?>) {
774                                    return null;
775                            }
776                            else {
777                                    return (PasswordPolicyRel)result;
778                            }
779                    }
780            }
781    
782            public PasswordPolicyRel findByP_C_C(long passwordPolicyId,
783                    long classNameId, long classPK)
784                    throws NoSuchPasswordPolicyRelException, SystemException {
785                    PasswordPolicyRel passwordPolicyRel = fetchByP_C_C(passwordPolicyId,
786                                    classNameId, classPK);
787    
788                    if (passwordPolicyRel == null) {
789                            StringBundler msg = new StringBundler(8);
790    
791                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
792    
793                            msg.append("passwordPolicyId=");
794                            msg.append(passwordPolicyId);
795    
796                            msg.append(", classNameId=");
797                            msg.append(classNameId);
798    
799                            msg.append(", classPK=");
800                            msg.append(classPK);
801    
802                            msg.append(StringPool.CLOSE_CURLY_BRACE);
803    
804                            if (_log.isWarnEnabled()) {
805                                    _log.warn(msg.toString());
806                            }
807    
808                            throw new NoSuchPasswordPolicyRelException(msg.toString());
809                    }
810    
811                    return passwordPolicyRel;
812            }
813    
814            public PasswordPolicyRel fetchByP_C_C(long passwordPolicyId,
815                    long classNameId, long classPK) throws SystemException {
816                    return fetchByP_C_C(passwordPolicyId, classNameId, classPK, true);
817            }
818    
819            public PasswordPolicyRel fetchByP_C_C(long passwordPolicyId,
820                    long classNameId, long classPK, boolean retrieveFromCache)
821                    throws SystemException {
822                    Object[] finderArgs = new Object[] {
823                                    passwordPolicyId, classNameId, classPK
824                            };
825    
826                    Object result = null;
827    
828                    if (retrieveFromCache) {
829                            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_P_C_C,
830                                            finderArgs, this);
831                    }
832    
833                    if (result == null) {
834                            Session session = null;
835    
836                            try {
837                                    session = openSession();
838    
839                                    StringBundler query = new StringBundler(4);
840    
841                                    query.append(_SQL_SELECT_PASSWORDPOLICYREL_WHERE);
842    
843                                    query.append(_FINDER_COLUMN_P_C_C_PASSWORDPOLICYID_2);
844    
845                                    query.append(_FINDER_COLUMN_P_C_C_CLASSNAMEID_2);
846    
847                                    query.append(_FINDER_COLUMN_P_C_C_CLASSPK_2);
848    
849                                    String sql = query.toString();
850    
851                                    Query q = session.createQuery(sql);
852    
853                                    QueryPos qPos = QueryPos.getInstance(q);
854    
855                                    qPos.add(passwordPolicyId);
856    
857                                    qPos.add(classNameId);
858    
859                                    qPos.add(classPK);
860    
861                                    List<PasswordPolicyRel> list = q.list();
862    
863                                    result = list;
864    
865                                    PasswordPolicyRel passwordPolicyRel = null;
866    
867                                    if (list.isEmpty()) {
868                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_P_C_C,
869                                                    finderArgs, list);
870                                    }
871                                    else {
872                                            passwordPolicyRel = list.get(0);
873    
874                                            cacheResult(passwordPolicyRel);
875    
876                                            if ((passwordPolicyRel.getPasswordPolicyId() != passwordPolicyId) ||
877                                                            (passwordPolicyRel.getClassNameId() != classNameId) ||
878                                                            (passwordPolicyRel.getClassPK() != classPK)) {
879                                                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_P_C_C,
880                                                            finderArgs, passwordPolicyRel);
881                                            }
882                                    }
883    
884                                    return passwordPolicyRel;
885                            }
886                            catch (Exception e) {
887                                    throw processException(e);
888                            }
889                            finally {
890                                    if (result == null) {
891                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_P_C_C,
892                                                    finderArgs, new ArrayList<PasswordPolicyRel>());
893                                    }
894    
895                                    closeSession(session);
896                            }
897                    }
898                    else {
899                            if (result instanceof List<?>) {
900                                    return null;
901                            }
902                            else {
903                                    return (PasswordPolicyRel)result;
904                            }
905                    }
906            }
907    
908            public List<PasswordPolicyRel> findAll() throws SystemException {
909                    return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
910            }
911    
912            public List<PasswordPolicyRel> findAll(int start, int end)
913                    throws SystemException {
914                    return findAll(start, end, null);
915            }
916    
917            public List<PasswordPolicyRel> findAll(int start, int end,
918                    OrderByComparator orderByComparator) throws SystemException {
919                    Object[] finderArgs = new Object[] {
920                                    String.valueOf(start), String.valueOf(end),
921                                    String.valueOf(orderByComparator)
922                            };
923    
924                    List<PasswordPolicyRel> list = (List<PasswordPolicyRel>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
925                                    finderArgs, this);
926    
927                    if (list == null) {
928                            Session session = null;
929    
930                            try {
931                                    session = openSession();
932    
933                                    StringBundler query = null;
934                                    String sql = null;
935    
936                                    if (orderByComparator != null) {
937                                            query = new StringBundler(2 +
938                                                            (orderByComparator.getOrderByFields().length * 3));
939    
940                                            query.append(_SQL_SELECT_PASSWORDPOLICYREL);
941    
942                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
943                                                    orderByComparator);
944    
945                                            sql = query.toString();
946                                    }
947                                    else {
948                                            sql = _SQL_SELECT_PASSWORDPOLICYREL;
949                                    }
950    
951                                    Query q = session.createQuery(sql);
952    
953                                    if (orderByComparator == null) {
954                                            list = (List<PasswordPolicyRel>)QueryUtil.list(q,
955                                                            getDialect(), start, end, false);
956    
957                                            Collections.sort(list);
958                                    }
959                                    else {
960                                            list = (List<PasswordPolicyRel>)QueryUtil.list(q,
961                                                            getDialect(), start, end);
962                                    }
963                            }
964                            catch (Exception e) {
965                                    throw processException(e);
966                            }
967                            finally {
968                                    if (list == null) {
969                                            list = new ArrayList<PasswordPolicyRel>();
970                                    }
971    
972                                    cacheResult(list);
973    
974                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
975    
976                                    closeSession(session);
977                            }
978                    }
979    
980                    return list;
981            }
982    
983            public void removeByPasswordPolicyId(long passwordPolicyId)
984                    throws SystemException {
985                    for (PasswordPolicyRel passwordPolicyRel : findByPasswordPolicyId(
986                                    passwordPolicyId)) {
987                            remove(passwordPolicyRel);
988                    }
989            }
990    
991            public void removeByC_C(long classNameId, long classPK)
992                    throws NoSuchPasswordPolicyRelException, SystemException {
993                    PasswordPolicyRel passwordPolicyRel = findByC_C(classNameId, classPK);
994    
995                    remove(passwordPolicyRel);
996            }
997    
998            public void removeByP_C_C(long passwordPolicyId, long classNameId,
999                    long classPK) throws NoSuchPasswordPolicyRelException, SystemException {
1000                    PasswordPolicyRel passwordPolicyRel = findByP_C_C(passwordPolicyId,
1001                                    classNameId, classPK);
1002    
1003                    remove(passwordPolicyRel);
1004            }
1005    
1006            public void removeAll() throws SystemException {
1007                    for (PasswordPolicyRel passwordPolicyRel : findAll()) {
1008                            remove(passwordPolicyRel);
1009                    }
1010            }
1011    
1012            public int countByPasswordPolicyId(long passwordPolicyId)
1013                    throws SystemException {
1014                    Object[] finderArgs = new Object[] { passwordPolicyId };
1015    
1016                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_PASSWORDPOLICYID,
1017                                    finderArgs, this);
1018    
1019                    if (count == null) {
1020                            Session session = null;
1021    
1022                            try {
1023                                    session = openSession();
1024    
1025                                    StringBundler query = new StringBundler(2);
1026    
1027                                    query.append(_SQL_COUNT_PASSWORDPOLICYREL_WHERE);
1028    
1029                                    query.append(_FINDER_COLUMN_PASSWORDPOLICYID_PASSWORDPOLICYID_2);
1030    
1031                                    String sql = query.toString();
1032    
1033                                    Query q = session.createQuery(sql);
1034    
1035                                    QueryPos qPos = QueryPos.getInstance(q);
1036    
1037                                    qPos.add(passwordPolicyId);
1038    
1039                                    count = (Long)q.uniqueResult();
1040                            }
1041                            catch (Exception e) {
1042                                    throw processException(e);
1043                            }
1044                            finally {
1045                                    if (count == null) {
1046                                            count = Long.valueOf(0);
1047                                    }
1048    
1049                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_PASSWORDPOLICYID,
1050                                            finderArgs, count);
1051    
1052                                    closeSession(session);
1053                            }
1054                    }
1055    
1056                    return count.intValue();
1057            }
1058    
1059            public int countByC_C(long classNameId, long classPK)
1060                    throws SystemException {
1061                    Object[] finderArgs = new Object[] { classNameId, classPK };
1062    
1063                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_C,
1064                                    finderArgs, this);
1065    
1066                    if (count == null) {
1067                            Session session = null;
1068    
1069                            try {
1070                                    session = openSession();
1071    
1072                                    StringBundler query = new StringBundler(3);
1073    
1074                                    query.append(_SQL_COUNT_PASSWORDPOLICYREL_WHERE);
1075    
1076                                    query.append(_FINDER_COLUMN_C_C_CLASSNAMEID_2);
1077    
1078                                    query.append(_FINDER_COLUMN_C_C_CLASSPK_2);
1079    
1080                                    String sql = query.toString();
1081    
1082                                    Query q = session.createQuery(sql);
1083    
1084                                    QueryPos qPos = QueryPos.getInstance(q);
1085    
1086                                    qPos.add(classNameId);
1087    
1088                                    qPos.add(classPK);
1089    
1090                                    count = (Long)q.uniqueResult();
1091                            }
1092                            catch (Exception e) {
1093                                    throw processException(e);
1094                            }
1095                            finally {
1096                                    if (count == null) {
1097                                            count = Long.valueOf(0);
1098                                    }
1099    
1100                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_C, finderArgs,
1101                                            count);
1102    
1103                                    closeSession(session);
1104                            }
1105                    }
1106    
1107                    return count.intValue();
1108            }
1109    
1110            public int countByP_C_C(long passwordPolicyId, long classNameId,
1111                    long classPK) throws SystemException {
1112                    Object[] finderArgs = new Object[] {
1113                                    passwordPolicyId, classNameId, classPK
1114                            };
1115    
1116                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_P_C_C,
1117                                    finderArgs, this);
1118    
1119                    if (count == null) {
1120                            Session session = null;
1121    
1122                            try {
1123                                    session = openSession();
1124    
1125                                    StringBundler query = new StringBundler(4);
1126    
1127                                    query.append(_SQL_COUNT_PASSWORDPOLICYREL_WHERE);
1128    
1129                                    query.append(_FINDER_COLUMN_P_C_C_PASSWORDPOLICYID_2);
1130    
1131                                    query.append(_FINDER_COLUMN_P_C_C_CLASSNAMEID_2);
1132    
1133                                    query.append(_FINDER_COLUMN_P_C_C_CLASSPK_2);
1134    
1135                                    String sql = query.toString();
1136    
1137                                    Query q = session.createQuery(sql);
1138    
1139                                    QueryPos qPos = QueryPos.getInstance(q);
1140    
1141                                    qPos.add(passwordPolicyId);
1142    
1143                                    qPos.add(classNameId);
1144    
1145                                    qPos.add(classPK);
1146    
1147                                    count = (Long)q.uniqueResult();
1148                            }
1149                            catch (Exception e) {
1150                                    throw processException(e);
1151                            }
1152                            finally {
1153                                    if (count == null) {
1154                                            count = Long.valueOf(0);
1155                                    }
1156    
1157                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_P_C_C,
1158                                            finderArgs, count);
1159    
1160                                    closeSession(session);
1161                            }
1162                    }
1163    
1164                    return count.intValue();
1165            }
1166    
1167            public int countAll() throws SystemException {
1168                    Object[] finderArgs = new Object[0];
1169    
1170                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
1171                                    finderArgs, this);
1172    
1173                    if (count == null) {
1174                            Session session = null;
1175    
1176                            try {
1177                                    session = openSession();
1178    
1179                                    Query q = session.createQuery(_SQL_COUNT_PASSWORDPOLICYREL);
1180    
1181                                    count = (Long)q.uniqueResult();
1182                            }
1183                            catch (Exception e) {
1184                                    throw processException(e);
1185                            }
1186                            finally {
1187                                    if (count == null) {
1188                                            count = Long.valueOf(0);
1189                                    }
1190    
1191                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
1192                                            count);
1193    
1194                                    closeSession(session);
1195                            }
1196                    }
1197    
1198                    return count.intValue();
1199            }
1200    
1201            public void afterPropertiesSet() {
1202                    String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
1203                                            com.liferay.portal.util.PropsUtil.get(
1204                                                    "value.object.listener.com.liferay.portal.model.PasswordPolicyRel")));
1205    
1206                    if (listenerClassNames.length > 0) {
1207                            try {
1208                                    List<ModelListener<PasswordPolicyRel>> listenersList = new ArrayList<ModelListener<PasswordPolicyRel>>();
1209    
1210                                    for (String listenerClassName : listenerClassNames) {
1211                                            listenersList.add((ModelListener<PasswordPolicyRel>)InstanceFactory.newInstance(
1212                                                            listenerClassName));
1213                                    }
1214    
1215                                    listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
1216                            }
1217                            catch (Exception e) {
1218                                    _log.error(e);
1219                            }
1220                    }
1221            }
1222    
1223            @BeanReference(type = AccountPersistence.class)
1224            protected AccountPersistence accountPersistence;
1225            @BeanReference(type = AddressPersistence.class)
1226            protected AddressPersistence addressPersistence;
1227            @BeanReference(type = BrowserTrackerPersistence.class)
1228            protected BrowserTrackerPersistence browserTrackerPersistence;
1229            @BeanReference(type = ClassNamePersistence.class)
1230            protected ClassNamePersistence classNamePersistence;
1231            @BeanReference(type = CompanyPersistence.class)
1232            protected CompanyPersistence companyPersistence;
1233            @BeanReference(type = ContactPersistence.class)
1234            protected ContactPersistence contactPersistence;
1235            @BeanReference(type = CountryPersistence.class)
1236            protected CountryPersistence countryPersistence;
1237            @BeanReference(type = EmailAddressPersistence.class)
1238            protected EmailAddressPersistence emailAddressPersistence;
1239            @BeanReference(type = GroupPersistence.class)
1240            protected GroupPersistence groupPersistence;
1241            @BeanReference(type = ImagePersistence.class)
1242            protected ImagePersistence imagePersistence;
1243            @BeanReference(type = LayoutPersistence.class)
1244            protected LayoutPersistence layoutPersistence;
1245            @BeanReference(type = LayoutPrototypePersistence.class)
1246            protected LayoutPrototypePersistence layoutPrototypePersistence;
1247            @BeanReference(type = LayoutSetPersistence.class)
1248            protected LayoutSetPersistence layoutSetPersistence;
1249            @BeanReference(type = LayoutSetPrototypePersistence.class)
1250            protected LayoutSetPrototypePersistence layoutSetPrototypePersistence;
1251            @BeanReference(type = ListTypePersistence.class)
1252            protected ListTypePersistence listTypePersistence;
1253            @BeanReference(type = LockPersistence.class)
1254            protected LockPersistence lockPersistence;
1255            @BeanReference(type = MembershipRequestPersistence.class)
1256            protected MembershipRequestPersistence membershipRequestPersistence;
1257            @BeanReference(type = OrganizationPersistence.class)
1258            protected OrganizationPersistence organizationPersistence;
1259            @BeanReference(type = OrgGroupPermissionPersistence.class)
1260            protected OrgGroupPermissionPersistence orgGroupPermissionPersistence;
1261            @BeanReference(type = OrgGroupRolePersistence.class)
1262            protected OrgGroupRolePersistence orgGroupRolePersistence;
1263            @BeanReference(type = OrgLaborPersistence.class)
1264            protected OrgLaborPersistence orgLaborPersistence;
1265            @BeanReference(type = PasswordPolicyPersistence.class)
1266            protected PasswordPolicyPersistence passwordPolicyPersistence;
1267            @BeanReference(type = PasswordPolicyRelPersistence.class)
1268            protected PasswordPolicyRelPersistence passwordPolicyRelPersistence;
1269            @BeanReference(type = PasswordTrackerPersistence.class)
1270            protected PasswordTrackerPersistence passwordTrackerPersistence;
1271            @BeanReference(type = PermissionPersistence.class)
1272            protected PermissionPersistence permissionPersistence;
1273            @BeanReference(type = PhonePersistence.class)
1274            protected PhonePersistence phonePersistence;
1275            @BeanReference(type = PluginSettingPersistence.class)
1276            protected PluginSettingPersistence pluginSettingPersistence;
1277            @BeanReference(type = PortletPersistence.class)
1278            protected PortletPersistence portletPersistence;
1279            @BeanReference(type = PortletItemPersistence.class)
1280            protected PortletItemPersistence portletItemPersistence;
1281            @BeanReference(type = PortletPreferencesPersistence.class)
1282            protected PortletPreferencesPersistence portletPreferencesPersistence;
1283            @BeanReference(type = RegionPersistence.class)
1284            protected RegionPersistence regionPersistence;
1285            @BeanReference(type = ReleasePersistence.class)
1286            protected ReleasePersistence releasePersistence;
1287            @BeanReference(type = ResourcePersistence.class)
1288            protected ResourcePersistence resourcePersistence;
1289            @BeanReference(type = ResourceActionPersistence.class)
1290            protected ResourceActionPersistence resourceActionPersistence;
1291            @BeanReference(type = ResourceCodePersistence.class)
1292            protected ResourceCodePersistence resourceCodePersistence;
1293            @BeanReference(type = ResourcePermissionPersistence.class)
1294            protected ResourcePermissionPersistence resourcePermissionPersistence;
1295            @BeanReference(type = RolePersistence.class)
1296            protected RolePersistence rolePersistence;
1297            @BeanReference(type = ServiceComponentPersistence.class)
1298            protected ServiceComponentPersistence serviceComponentPersistence;
1299            @BeanReference(type = ShardPersistence.class)
1300            protected ShardPersistence shardPersistence;
1301            @BeanReference(type = SubscriptionPersistence.class)
1302            protected SubscriptionPersistence subscriptionPersistence;
1303            @BeanReference(type = TicketPersistence.class)
1304            protected TicketPersistence ticketPersistence;
1305            @BeanReference(type = TeamPersistence.class)
1306            protected TeamPersistence teamPersistence;
1307            @BeanReference(type = UserPersistence.class)
1308            protected UserPersistence userPersistence;
1309            @BeanReference(type = UserGroupPersistence.class)
1310            protected UserGroupPersistence userGroupPersistence;
1311            @BeanReference(type = UserGroupGroupRolePersistence.class)
1312            protected UserGroupGroupRolePersistence userGroupGroupRolePersistence;
1313            @BeanReference(type = UserGroupRolePersistence.class)
1314            protected UserGroupRolePersistence userGroupRolePersistence;
1315            @BeanReference(type = UserIdMapperPersistence.class)
1316            protected UserIdMapperPersistence userIdMapperPersistence;
1317            @BeanReference(type = UserTrackerPersistence.class)
1318            protected UserTrackerPersistence userTrackerPersistence;
1319            @BeanReference(type = UserTrackerPathPersistence.class)
1320            protected UserTrackerPathPersistence userTrackerPathPersistence;
1321            @BeanReference(type = WebDAVPropsPersistence.class)
1322            protected WebDAVPropsPersistence webDAVPropsPersistence;
1323            @BeanReference(type = WebsitePersistence.class)
1324            protected WebsitePersistence websitePersistence;
1325            @BeanReference(type = WorkflowDefinitionLinkPersistence.class)
1326            protected WorkflowDefinitionLinkPersistence workflowDefinitionLinkPersistence;
1327            @BeanReference(type = WorkflowInstanceLinkPersistence.class)
1328            protected WorkflowInstanceLinkPersistence workflowInstanceLinkPersistence;
1329            private static final String _SQL_SELECT_PASSWORDPOLICYREL = "SELECT passwordPolicyRel FROM PasswordPolicyRel passwordPolicyRel";
1330            private static final String _SQL_SELECT_PASSWORDPOLICYREL_WHERE = "SELECT passwordPolicyRel FROM PasswordPolicyRel passwordPolicyRel WHERE ";
1331            private static final String _SQL_COUNT_PASSWORDPOLICYREL = "SELECT COUNT(passwordPolicyRel) FROM PasswordPolicyRel passwordPolicyRel";
1332            private static final String _SQL_COUNT_PASSWORDPOLICYREL_WHERE = "SELECT COUNT(passwordPolicyRel) FROM PasswordPolicyRel passwordPolicyRel WHERE ";
1333            private static final String _FINDER_COLUMN_PASSWORDPOLICYID_PASSWORDPOLICYID_2 =
1334                    "passwordPolicyRel.passwordPolicyId = ?";
1335            private static final String _FINDER_COLUMN_C_C_CLASSNAMEID_2 = "passwordPolicyRel.classNameId = ? AND ";
1336            private static final String _FINDER_COLUMN_C_C_CLASSPK_2 = "passwordPolicyRel.classPK = ?";
1337            private static final String _FINDER_COLUMN_P_C_C_PASSWORDPOLICYID_2 = "passwordPolicyRel.passwordPolicyId = ? AND ";
1338            private static final String _FINDER_COLUMN_P_C_C_CLASSNAMEID_2 = "passwordPolicyRel.classNameId = ? AND ";
1339            private static final String _FINDER_COLUMN_P_C_C_CLASSPK_2 = "passwordPolicyRel.classPK = ?";
1340            private static final String _ORDER_BY_ENTITY_ALIAS = "passwordPolicyRel.";
1341            private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No PasswordPolicyRel exists with the primary key ";
1342            private static final String _NO_SUCH_ENTITY_WITH_KEY = "No PasswordPolicyRel exists with the key {";
1343            private static Log _log = LogFactoryUtil.getLog(PasswordPolicyRelPersistenceImpl.class);
1344    }