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.NoSuchLayoutException;
018    import com.liferay.portal.NoSuchModelException;
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.kernel.uuid.PortalUUIDUtil;
039    import com.liferay.portal.model.Layout;
040    import com.liferay.portal.model.ModelListener;
041    import com.liferay.portal.model.impl.LayoutImpl;
042    import com.liferay.portal.model.impl.LayoutModelImpl;
043    import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
044    
045    import com.liferay.portlet.documentlibrary.service.persistence.DLFolderPersistence;
046    import com.liferay.portlet.expando.service.persistence.ExpandoValuePersistence;
047    import com.liferay.portlet.journal.service.persistence.JournalContentSearchPersistence;
048    import com.liferay.portlet.messageboards.service.persistence.MBMessagePersistence;
049    import com.liferay.portlet.ratings.service.persistence.RatingsStatsPersistence;
050    import com.liferay.portlet.tasks.service.persistence.TasksProposalPersistence;
051    
052    import java.io.Serializable;
053    
054    import java.util.ArrayList;
055    import java.util.Collections;
056    import java.util.List;
057    
058    /**
059     * @author    Brian Wing Shun Chan
060     * @see       LayoutPersistence
061     * @see       LayoutUtil
062     * @generated
063     */
064    public class LayoutPersistenceImpl extends BasePersistenceImpl<Layout>
065            implements LayoutPersistence {
066            public static final String FINDER_CLASS_NAME_ENTITY = LayoutImpl.class.getName();
067            public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
068                    ".List";
069            public static final FinderPath FINDER_PATH_FIND_BY_UUID = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
070                            LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
071                            "findByUuid",
072                            new String[] {
073                                    String.class.getName(),
074                                    
075                            "java.lang.Integer", "java.lang.Integer",
076                                    "com.liferay.portal.kernel.util.OrderByComparator"
077                            });
078            public static final FinderPath FINDER_PATH_COUNT_BY_UUID = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
079                            LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
080                            "countByUuid", new String[] { String.class.getName() });
081            public static final FinderPath FINDER_PATH_FETCH_BY_UUID_G = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
082                            LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_ENTITY,
083                            "fetchByUUID_G",
084                            new String[] { String.class.getName(), Long.class.getName() });
085            public static final FinderPath FINDER_PATH_COUNT_BY_UUID_G = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
086                            LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
087                            "countByUUID_G",
088                            new String[] { String.class.getName(), Long.class.getName() });
089            public static final FinderPath FINDER_PATH_FIND_BY_GROUPID = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
090                            LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
091                            "findByGroupId",
092                            new String[] {
093                                    Long.class.getName(),
094                                    
095                            "java.lang.Integer", "java.lang.Integer",
096                                    "com.liferay.portal.kernel.util.OrderByComparator"
097                            });
098            public static final FinderPath FINDER_PATH_COUNT_BY_GROUPID = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
099                            LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
100                            "countByGroupId", new String[] { Long.class.getName() });
101            public static final FinderPath FINDER_PATH_FIND_BY_COMPANYID = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
102                            LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
103                            "findByCompanyId",
104                            new String[] {
105                                    Long.class.getName(),
106                                    
107                            "java.lang.Integer", "java.lang.Integer",
108                                    "com.liferay.portal.kernel.util.OrderByComparator"
109                            });
110            public static final FinderPath FINDER_PATH_COUNT_BY_COMPANYID = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
111                            LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
112                            "countByCompanyId", new String[] { Long.class.getName() });
113            public static final FinderPath FINDER_PATH_FETCH_BY_DLFOLDERID = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
114                            LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_ENTITY,
115                            "fetchByDLFolderId", new String[] { Long.class.getName() });
116            public static final FinderPath FINDER_PATH_COUNT_BY_DLFOLDERID = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
117                            LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
118                            "countByDLFolderId", new String[] { Long.class.getName() });
119            public static final FinderPath FINDER_PATH_FETCH_BY_ICONIMAGEID = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
120                            LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_ENTITY,
121                            "fetchByIconImageId", new String[] { Long.class.getName() });
122            public static final FinderPath FINDER_PATH_COUNT_BY_ICONIMAGEID = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
123                            LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
124                            "countByIconImageId", new String[] { Long.class.getName() });
125            public static final FinderPath FINDER_PATH_FIND_BY_G_P = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
126                            LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
127                            "findByG_P",
128                            new String[] {
129                                    Long.class.getName(), Boolean.class.getName(),
130                                    
131                            "java.lang.Integer", "java.lang.Integer",
132                                    "com.liferay.portal.kernel.util.OrderByComparator"
133                            });
134            public static final FinderPath FINDER_PATH_COUNT_BY_G_P = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
135                            LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
136                            "countByG_P",
137                            new String[] { Long.class.getName(), Boolean.class.getName() });
138            public static final FinderPath FINDER_PATH_FETCH_BY_G_P_L = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
139                            LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_ENTITY,
140                            "fetchByG_P_L",
141                            new String[] {
142                                    Long.class.getName(), Boolean.class.getName(),
143                                    Long.class.getName()
144                            });
145            public static final FinderPath FINDER_PATH_COUNT_BY_G_P_L = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
146                            LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
147                            "countByG_P_L",
148                            new String[] {
149                                    Long.class.getName(), Boolean.class.getName(),
150                                    Long.class.getName()
151                            });
152            public static final FinderPath FINDER_PATH_FIND_BY_G_P_P = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
153                            LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
154                            "findByG_P_P",
155                            new String[] {
156                                    Long.class.getName(), Boolean.class.getName(),
157                                    Long.class.getName(),
158                                    
159                            "java.lang.Integer", "java.lang.Integer",
160                                    "com.liferay.portal.kernel.util.OrderByComparator"
161                            });
162            public static final FinderPath FINDER_PATH_COUNT_BY_G_P_P = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
163                            LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
164                            "countByG_P_P",
165                            new String[] {
166                                    Long.class.getName(), Boolean.class.getName(),
167                                    Long.class.getName()
168                            });
169            public static final FinderPath FINDER_PATH_FETCH_BY_G_P_F = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
170                            LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_ENTITY,
171                            "fetchByG_P_F",
172                            new String[] {
173                                    Long.class.getName(), Boolean.class.getName(),
174                                    String.class.getName()
175                            });
176            public static final FinderPath FINDER_PATH_COUNT_BY_G_P_F = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
177                            LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
178                            "countByG_P_F",
179                            new String[] {
180                                    Long.class.getName(), Boolean.class.getName(),
181                                    String.class.getName()
182                            });
183            public static final FinderPath FINDER_PATH_FIND_BY_G_P_T = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
184                            LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
185                            "findByG_P_T",
186                            new String[] {
187                                    Long.class.getName(), Boolean.class.getName(),
188                                    String.class.getName(),
189                                    
190                            "java.lang.Integer", "java.lang.Integer",
191                                    "com.liferay.portal.kernel.util.OrderByComparator"
192                            });
193            public static final FinderPath FINDER_PATH_COUNT_BY_G_P_T = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
194                            LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
195                            "countByG_P_T",
196                            new String[] {
197                                    Long.class.getName(), Boolean.class.getName(),
198                                    String.class.getName()
199                            });
200            public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
201                            LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
202                            "findAll", new String[0]);
203            public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(LayoutModelImpl.ENTITY_CACHE_ENABLED,
204                            LayoutModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
205                            "countAll", new String[0]);
206    
207            public void cacheResult(Layout layout) {
208                    EntityCacheUtil.putResult(LayoutModelImpl.ENTITY_CACHE_ENABLED,
209                            LayoutImpl.class, layout.getPrimaryKey(), layout);
210    
211                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
212                            new Object[] { layout.getUuid(), new Long(layout.getGroupId()) },
213                            layout);
214    
215                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_DLFOLDERID,
216                            new Object[] { new Long(layout.getDlFolderId()) }, layout);
217    
218                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_ICONIMAGEID,
219                            new Object[] { new Long(layout.getIconImageId()) }, layout);
220    
221                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_P_L,
222                            new Object[] {
223                                    new Long(layout.getGroupId()),
224                                    Boolean.valueOf(layout.getPrivateLayout()),
225                                    new Long(layout.getLayoutId())
226                            }, layout);
227    
228                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_P_F,
229                            new Object[] {
230                                    new Long(layout.getGroupId()),
231                                    Boolean.valueOf(layout.getPrivateLayout()),
232                                    
233                            layout.getFriendlyURL()
234                            }, layout);
235            }
236    
237            public void cacheResult(List<Layout> layouts) {
238                    for (Layout layout : layouts) {
239                            if (EntityCacheUtil.getResult(
240                                                    LayoutModelImpl.ENTITY_CACHE_ENABLED, LayoutImpl.class,
241                                                    layout.getPrimaryKey(), this) == null) {
242                                    cacheResult(layout);
243                            }
244                    }
245            }
246    
247            public void clearCache() {
248                    CacheRegistryUtil.clear(LayoutImpl.class.getName());
249                    EntityCacheUtil.clearCache(LayoutImpl.class.getName());
250                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
251                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
252            }
253    
254            public void clearCache(Layout layout) {
255                    EntityCacheUtil.removeResult(LayoutModelImpl.ENTITY_CACHE_ENABLED,
256                            LayoutImpl.class, layout.getPrimaryKey());
257    
258                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
259                            new Object[] { layout.getUuid(), new Long(layout.getGroupId()) });
260    
261                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_DLFOLDERID,
262                            new Object[] { new Long(layout.getDlFolderId()) });
263    
264                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_ICONIMAGEID,
265                            new Object[] { new Long(layout.getIconImageId()) });
266    
267                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_P_L,
268                            new Object[] {
269                                    new Long(layout.getGroupId()),
270                                    Boolean.valueOf(layout.getPrivateLayout()),
271                                    new Long(layout.getLayoutId())
272                            });
273    
274                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_P_F,
275                            new Object[] {
276                                    new Long(layout.getGroupId()),
277                                    Boolean.valueOf(layout.getPrivateLayout()),
278                                    
279                            layout.getFriendlyURL()
280                            });
281            }
282    
283            public Layout create(long plid) {
284                    Layout layout = new LayoutImpl();
285    
286                    layout.setNew(true);
287                    layout.setPrimaryKey(plid);
288    
289                    String uuid = PortalUUIDUtil.generate();
290    
291                    layout.setUuid(uuid);
292    
293                    return layout;
294            }
295    
296            public Layout remove(Serializable primaryKey)
297                    throws NoSuchModelException, SystemException {
298                    return remove(((Long)primaryKey).longValue());
299            }
300    
301            public Layout remove(long plid)
302                    throws NoSuchLayoutException, SystemException {
303                    Session session = null;
304    
305                    try {
306                            session = openSession();
307    
308                            Layout layout = (Layout)session.get(LayoutImpl.class, new Long(plid));
309    
310                            if (layout == null) {
311                                    if (_log.isWarnEnabled()) {
312                                            _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + plid);
313                                    }
314    
315                                    throw new NoSuchLayoutException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
316                                            plid);
317                            }
318    
319                            return remove(layout);
320                    }
321                    catch (NoSuchLayoutException nsee) {
322                            throw nsee;
323                    }
324                    catch (Exception e) {
325                            throw processException(e);
326                    }
327                    finally {
328                            closeSession(session);
329                    }
330            }
331    
332            protected Layout removeImpl(Layout layout) throws SystemException {
333                    layout = toUnwrappedModel(layout);
334    
335                    Session session = null;
336    
337                    try {
338                            session = openSession();
339    
340                            if (layout.isCachedModel() || BatchSessionUtil.isEnabled()) {
341                                    Object staleObject = session.get(LayoutImpl.class,
342                                                    layout.getPrimaryKeyObj());
343    
344                                    if (staleObject != null) {
345                                            session.evict(staleObject);
346                                    }
347                            }
348    
349                            session.delete(layout);
350    
351                            session.flush();
352                    }
353                    catch (Exception e) {
354                            throw processException(e);
355                    }
356                    finally {
357                            closeSession(session);
358                    }
359    
360                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
361    
362                    LayoutModelImpl layoutModelImpl = (LayoutModelImpl)layout;
363    
364                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
365                            new Object[] {
366                                    layoutModelImpl.getOriginalUuid(),
367                                    new Long(layoutModelImpl.getOriginalGroupId())
368                            });
369    
370                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_DLFOLDERID,
371                            new Object[] { new Long(layoutModelImpl.getOriginalDlFolderId()) });
372    
373                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_ICONIMAGEID,
374                            new Object[] { new Long(layoutModelImpl.getOriginalIconImageId()) });
375    
376                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_P_L,
377                            new Object[] {
378                                    new Long(layoutModelImpl.getOriginalGroupId()),
379                                    Boolean.valueOf(layoutModelImpl.getOriginalPrivateLayout()),
380                                    new Long(layoutModelImpl.getOriginalLayoutId())
381                            });
382    
383                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_P_F,
384                            new Object[] {
385                                    new Long(layoutModelImpl.getOriginalGroupId()),
386                                    Boolean.valueOf(layoutModelImpl.getOriginalPrivateLayout()),
387                                    
388                            layoutModelImpl.getOriginalFriendlyURL()
389                            });
390    
391                    EntityCacheUtil.removeResult(LayoutModelImpl.ENTITY_CACHE_ENABLED,
392                            LayoutImpl.class, layout.getPrimaryKey());
393    
394                    return layout;
395            }
396    
397            public Layout updateImpl(com.liferay.portal.model.Layout layout,
398                    boolean merge) throws SystemException {
399                    layout = toUnwrappedModel(layout);
400    
401                    boolean isNew = layout.isNew();
402    
403                    LayoutModelImpl layoutModelImpl = (LayoutModelImpl)layout;
404    
405                    if (Validator.isNull(layout.getUuid())) {
406                            String uuid = PortalUUIDUtil.generate();
407    
408                            layout.setUuid(uuid);
409                    }
410    
411                    Session session = null;
412    
413                    try {
414                            session = openSession();
415    
416                            BatchSessionUtil.update(session, layout, merge);
417    
418                            layout.setNew(false);
419                    }
420                    catch (Exception e) {
421                            throw processException(e);
422                    }
423                    finally {
424                            closeSession(session);
425                    }
426    
427                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
428    
429                    EntityCacheUtil.putResult(LayoutModelImpl.ENTITY_CACHE_ENABLED,
430                            LayoutImpl.class, layout.getPrimaryKey(), layout);
431    
432                    if (!isNew &&
433                                    (!Validator.equals(layout.getUuid(),
434                                            layoutModelImpl.getOriginalUuid()) ||
435                                    (layout.getGroupId() != layoutModelImpl.getOriginalGroupId()))) {
436                            FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
437                                    new Object[] {
438                                            layoutModelImpl.getOriginalUuid(),
439                                            new Long(layoutModelImpl.getOriginalGroupId())
440                                    });
441                    }
442    
443                    if (isNew ||
444                                    (!Validator.equals(layout.getUuid(),
445                                            layoutModelImpl.getOriginalUuid()) ||
446                                    (layout.getGroupId() != layoutModelImpl.getOriginalGroupId()))) {
447                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
448                                    new Object[] { layout.getUuid(), new Long(layout.getGroupId()) },
449                                    layout);
450                    }
451    
452                    if (!isNew &&
453                                    (layout.getDlFolderId() != layoutModelImpl.getOriginalDlFolderId())) {
454                            FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_DLFOLDERID,
455                                    new Object[] { new Long(layoutModelImpl.getOriginalDlFolderId()) });
456                    }
457    
458                    if (isNew ||
459                                    (layout.getDlFolderId() != layoutModelImpl.getOriginalDlFolderId())) {
460                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_DLFOLDERID,
461                                    new Object[] { new Long(layout.getDlFolderId()) }, layout);
462                    }
463    
464                    if (!isNew &&
465                                    (layout.getIconImageId() != layoutModelImpl.getOriginalIconImageId())) {
466                            FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_ICONIMAGEID,
467                                    new Object[] { new Long(layoutModelImpl.getOriginalIconImageId()) });
468                    }
469    
470                    if (isNew ||
471                                    (layout.getIconImageId() != layoutModelImpl.getOriginalIconImageId())) {
472                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_ICONIMAGEID,
473                                    new Object[] { new Long(layout.getIconImageId()) }, layout);
474                    }
475    
476                    if (!isNew &&
477                                    ((layout.getGroupId() != layoutModelImpl.getOriginalGroupId()) ||
478                                    (layout.getPrivateLayout() != layoutModelImpl.getOriginalPrivateLayout()) ||
479                                    (layout.getLayoutId() != layoutModelImpl.getOriginalLayoutId()))) {
480                            FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_P_L,
481                                    new Object[] {
482                                            new Long(layoutModelImpl.getOriginalGroupId()),
483                                            Boolean.valueOf(layoutModelImpl.getOriginalPrivateLayout()),
484                                            new Long(layoutModelImpl.getOriginalLayoutId())
485                                    });
486                    }
487    
488                    if (isNew ||
489                                    ((layout.getGroupId() != layoutModelImpl.getOriginalGroupId()) ||
490                                    (layout.getPrivateLayout() != layoutModelImpl.getOriginalPrivateLayout()) ||
491                                    (layout.getLayoutId() != layoutModelImpl.getOriginalLayoutId()))) {
492                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_P_L,
493                                    new Object[] {
494                                            new Long(layout.getGroupId()),
495                                            Boolean.valueOf(layout.getPrivateLayout()),
496                                            new Long(layout.getLayoutId())
497                                    }, layout);
498                    }
499    
500                    if (!isNew &&
501                                    ((layout.getGroupId() != layoutModelImpl.getOriginalGroupId()) ||
502                                    (layout.getPrivateLayout() != layoutModelImpl.getOriginalPrivateLayout()) ||
503                                    !Validator.equals(layout.getFriendlyURL(),
504                                            layoutModelImpl.getOriginalFriendlyURL()))) {
505                            FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_P_F,
506                                    new Object[] {
507                                            new Long(layoutModelImpl.getOriginalGroupId()),
508                                            Boolean.valueOf(layoutModelImpl.getOriginalPrivateLayout()),
509                                            
510                                    layoutModelImpl.getOriginalFriendlyURL()
511                                    });
512                    }
513    
514                    if (isNew ||
515                                    ((layout.getGroupId() != layoutModelImpl.getOriginalGroupId()) ||
516                                    (layout.getPrivateLayout() != layoutModelImpl.getOriginalPrivateLayout()) ||
517                                    !Validator.equals(layout.getFriendlyURL(),
518                                            layoutModelImpl.getOriginalFriendlyURL()))) {
519                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_P_F,
520                                    new Object[] {
521                                            new Long(layout.getGroupId()),
522                                            Boolean.valueOf(layout.getPrivateLayout()),
523                                            
524                                    layout.getFriendlyURL()
525                                    }, layout);
526                    }
527    
528                    return layout;
529            }
530    
531            protected Layout toUnwrappedModel(Layout layout) {
532                    if (layout instanceof LayoutImpl) {
533                            return layout;
534                    }
535    
536                    LayoutImpl layoutImpl = new LayoutImpl();
537    
538                    layoutImpl.setNew(layout.isNew());
539                    layoutImpl.setPrimaryKey(layout.getPrimaryKey());
540    
541                    layoutImpl.setUuid(layout.getUuid());
542                    layoutImpl.setPlid(layout.getPlid());
543                    layoutImpl.setGroupId(layout.getGroupId());
544                    layoutImpl.setCompanyId(layout.getCompanyId());
545                    layoutImpl.setPrivateLayout(layout.isPrivateLayout());
546                    layoutImpl.setLayoutId(layout.getLayoutId());
547                    layoutImpl.setParentLayoutId(layout.getParentLayoutId());
548                    layoutImpl.setName(layout.getName());
549                    layoutImpl.setTitle(layout.getTitle());
550                    layoutImpl.setDescription(layout.getDescription());
551                    layoutImpl.setType(layout.getType());
552                    layoutImpl.setTypeSettings(layout.getTypeSettings());
553                    layoutImpl.setHidden(layout.isHidden());
554                    layoutImpl.setFriendlyURL(layout.getFriendlyURL());
555                    layoutImpl.setIconImage(layout.isIconImage());
556                    layoutImpl.setIconImageId(layout.getIconImageId());
557                    layoutImpl.setThemeId(layout.getThemeId());
558                    layoutImpl.setColorSchemeId(layout.getColorSchemeId());
559                    layoutImpl.setWapThemeId(layout.getWapThemeId());
560                    layoutImpl.setWapColorSchemeId(layout.getWapColorSchemeId());
561                    layoutImpl.setCss(layout.getCss());
562                    layoutImpl.setPriority(layout.getPriority());
563                    layoutImpl.setLayoutPrototypeId(layout.getLayoutPrototypeId());
564                    layoutImpl.setDlFolderId(layout.getDlFolderId());
565    
566                    return layoutImpl;
567            }
568    
569            public Layout findByPrimaryKey(Serializable primaryKey)
570                    throws NoSuchModelException, SystemException {
571                    return findByPrimaryKey(((Long)primaryKey).longValue());
572            }
573    
574            public Layout findByPrimaryKey(long plid)
575                    throws NoSuchLayoutException, SystemException {
576                    Layout layout = fetchByPrimaryKey(plid);
577    
578                    if (layout == null) {
579                            if (_log.isWarnEnabled()) {
580                                    _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + plid);
581                            }
582    
583                            throw new NoSuchLayoutException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
584                                    plid);
585                    }
586    
587                    return layout;
588            }
589    
590            public Layout fetchByPrimaryKey(Serializable primaryKey)
591                    throws SystemException {
592                    return fetchByPrimaryKey(((Long)primaryKey).longValue());
593            }
594    
595            public Layout fetchByPrimaryKey(long plid) throws SystemException {
596                    Layout layout = (Layout)EntityCacheUtil.getResult(LayoutModelImpl.ENTITY_CACHE_ENABLED,
597                                    LayoutImpl.class, plid, this);
598    
599                    if (layout == null) {
600                            Session session = null;
601    
602                            try {
603                                    session = openSession();
604    
605                                    layout = (Layout)session.get(LayoutImpl.class, new Long(plid));
606                            }
607                            catch (Exception e) {
608                                    throw processException(e);
609                            }
610                            finally {
611                                    if (layout != null) {
612                                            cacheResult(layout);
613                                    }
614    
615                                    closeSession(session);
616                            }
617                    }
618    
619                    return layout;
620            }
621    
622            public List<Layout> findByUuid(String uuid) throws SystemException {
623                    return findByUuid(uuid, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
624            }
625    
626            public List<Layout> findByUuid(String uuid, int start, int end)
627                    throws SystemException {
628                    return findByUuid(uuid, start, end, null);
629            }
630    
631            public List<Layout> findByUuid(String uuid, int start, int end,
632                    OrderByComparator orderByComparator) throws SystemException {
633                    Object[] finderArgs = new Object[] {
634                                    uuid,
635                                    
636                                    String.valueOf(start), String.valueOf(end),
637                                    String.valueOf(orderByComparator)
638                            };
639    
640                    List<Layout> list = (List<Layout>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_UUID,
641                                    finderArgs, this);
642    
643                    if (list == null) {
644                            Session session = null;
645    
646                            try {
647                                    session = openSession();
648    
649                                    StringBundler query = null;
650    
651                                    if (orderByComparator != null) {
652                                            query = new StringBundler(3 +
653                                                            (orderByComparator.getOrderByFields().length * 3));
654                                    }
655                                    else {
656                                            query = new StringBundler(3);
657                                    }
658    
659                                    query.append(_SQL_SELECT_LAYOUT_WHERE);
660    
661                                    if (uuid == null) {
662                                            query.append(_FINDER_COLUMN_UUID_UUID_1);
663                                    }
664                                    else {
665                                            if (uuid.equals(StringPool.BLANK)) {
666                                                    query.append(_FINDER_COLUMN_UUID_UUID_3);
667                                            }
668                                            else {
669                                                    query.append(_FINDER_COLUMN_UUID_UUID_2);
670                                            }
671                                    }
672    
673                                    if (orderByComparator != null) {
674                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
675                                                    orderByComparator);
676                                    }
677    
678                                    else {
679                                            query.append(LayoutModelImpl.ORDER_BY_JPQL);
680                                    }
681    
682                                    String sql = query.toString();
683    
684                                    Query q = session.createQuery(sql);
685    
686                                    QueryPos qPos = QueryPos.getInstance(q);
687    
688                                    if (uuid != null) {
689                                            qPos.add(uuid);
690                                    }
691    
692                                    list = (List<Layout>)QueryUtil.list(q, getDialect(), start, end);
693                            }
694                            catch (Exception e) {
695                                    throw processException(e);
696                            }
697                            finally {
698                                    if (list == null) {
699                                            list = new ArrayList<Layout>();
700                                    }
701    
702                                    cacheResult(list);
703    
704                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_UUID, finderArgs,
705                                            list);
706    
707                                    closeSession(session);
708                            }
709                    }
710    
711                    return list;
712            }
713    
714            public Layout findByUuid_First(String uuid,
715                    OrderByComparator orderByComparator)
716                    throws NoSuchLayoutException, SystemException {
717                    List<Layout> list = findByUuid(uuid, 0, 1, orderByComparator);
718    
719                    if (list.isEmpty()) {
720                            StringBundler msg = new StringBundler(4);
721    
722                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
723    
724                            msg.append("uuid=");
725                            msg.append(uuid);
726    
727                            msg.append(StringPool.CLOSE_CURLY_BRACE);
728    
729                            throw new NoSuchLayoutException(msg.toString());
730                    }
731                    else {
732                            return list.get(0);
733                    }
734            }
735    
736            public Layout findByUuid_Last(String uuid,
737                    OrderByComparator orderByComparator)
738                    throws NoSuchLayoutException, SystemException {
739                    int count = countByUuid(uuid);
740    
741                    List<Layout> list = findByUuid(uuid, count - 1, count, orderByComparator);
742    
743                    if (list.isEmpty()) {
744                            StringBundler msg = new StringBundler(4);
745    
746                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
747    
748                            msg.append("uuid=");
749                            msg.append(uuid);
750    
751                            msg.append(StringPool.CLOSE_CURLY_BRACE);
752    
753                            throw new NoSuchLayoutException(msg.toString());
754                    }
755                    else {
756                            return list.get(0);
757                    }
758            }
759    
760            public Layout[] findByUuid_PrevAndNext(long plid, String uuid,
761                    OrderByComparator orderByComparator)
762                    throws NoSuchLayoutException, SystemException {
763                    Layout layout = findByPrimaryKey(plid);
764    
765                    Session session = null;
766    
767                    try {
768                            session = openSession();
769    
770                            Layout[] array = new LayoutImpl[3];
771    
772                            array[0] = getByUuid_PrevAndNext(session, layout, uuid,
773                                            orderByComparator, true);
774    
775                            array[1] = layout;
776    
777                            array[2] = getByUuid_PrevAndNext(session, layout, uuid,
778                                            orderByComparator, false);
779    
780                            return array;
781                    }
782                    catch (Exception e) {
783                            throw processException(e);
784                    }
785                    finally {
786                            closeSession(session);
787                    }
788            }
789    
790            protected Layout getByUuid_PrevAndNext(Session session, Layout layout,
791                    String uuid, OrderByComparator orderByComparator, boolean previous) {
792                    StringBundler query = null;
793    
794                    if (orderByComparator != null) {
795                            query = new StringBundler(6 +
796                                            (orderByComparator.getOrderByFields().length * 6));
797                    }
798                    else {
799                            query = new StringBundler(3);
800                    }
801    
802                    query.append(_SQL_SELECT_LAYOUT_WHERE);
803    
804                    if (uuid == null) {
805                            query.append(_FINDER_COLUMN_UUID_UUID_1);
806                    }
807                    else {
808                            if (uuid.equals(StringPool.BLANK)) {
809                                    query.append(_FINDER_COLUMN_UUID_UUID_3);
810                            }
811                            else {
812                                    query.append(_FINDER_COLUMN_UUID_UUID_2);
813                            }
814                    }
815    
816                    if (orderByComparator != null) {
817                            String[] orderByFields = orderByComparator.getOrderByFields();
818    
819                            if (orderByFields.length > 0) {
820                                    query.append(WHERE_AND);
821                            }
822    
823                            for (int i = 0; i < orderByFields.length; i++) {
824                                    query.append(_ORDER_BY_ENTITY_ALIAS);
825                                    query.append(orderByFields[i]);
826    
827                                    if ((i + 1) < orderByFields.length) {
828                                            if (orderByComparator.isAscending() ^ previous) {
829                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
830                                            }
831                                            else {
832                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
833                                            }
834                                    }
835                                    else {
836                                            if (orderByComparator.isAscending() ^ previous) {
837                                                    query.append(WHERE_GREATER_THAN);
838                                            }
839                                            else {
840                                                    query.append(WHERE_LESSER_THAN);
841                                            }
842                                    }
843                            }
844    
845                            query.append(ORDER_BY_CLAUSE);
846    
847                            for (int i = 0; i < orderByFields.length; i++) {
848                                    query.append(_ORDER_BY_ENTITY_ALIAS);
849                                    query.append(orderByFields[i]);
850    
851                                    if ((i + 1) < orderByFields.length) {
852                                            if (orderByComparator.isAscending() ^ previous) {
853                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
854                                            }
855                                            else {
856                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
857                                            }
858                                    }
859                                    else {
860                                            if (orderByComparator.isAscending() ^ previous) {
861                                                    query.append(ORDER_BY_ASC);
862                                            }
863                                            else {
864                                                    query.append(ORDER_BY_DESC);
865                                            }
866                                    }
867                            }
868                    }
869    
870                    else {
871                            query.append(LayoutModelImpl.ORDER_BY_JPQL);
872                    }
873    
874                    String sql = query.toString();
875    
876                    Query q = session.createQuery(sql);
877    
878                    q.setFirstResult(0);
879                    q.setMaxResults(2);
880    
881                    QueryPos qPos = QueryPos.getInstance(q);
882    
883                    if (uuid != null) {
884                            qPos.add(uuid);
885                    }
886    
887                    if (orderByComparator != null) {
888                            Object[] values = orderByComparator.getOrderByValues(layout);
889    
890                            for (Object value : values) {
891                                    qPos.add(value);
892                            }
893                    }
894    
895                    List<Layout> list = q.list();
896    
897                    if (list.size() == 2) {
898                            return list.get(1);
899                    }
900                    else {
901                            return null;
902                    }
903            }
904    
905            public Layout findByUUID_G(String uuid, long groupId)
906                    throws NoSuchLayoutException, SystemException {
907                    Layout layout = fetchByUUID_G(uuid, groupId);
908    
909                    if (layout == null) {
910                            StringBundler msg = new StringBundler(6);
911    
912                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
913    
914                            msg.append("uuid=");
915                            msg.append(uuid);
916    
917                            msg.append(", groupId=");
918                            msg.append(groupId);
919    
920                            msg.append(StringPool.CLOSE_CURLY_BRACE);
921    
922                            if (_log.isWarnEnabled()) {
923                                    _log.warn(msg.toString());
924                            }
925    
926                            throw new NoSuchLayoutException(msg.toString());
927                    }
928    
929                    return layout;
930            }
931    
932            public Layout fetchByUUID_G(String uuid, long groupId)
933                    throws SystemException {
934                    return fetchByUUID_G(uuid, groupId, true);
935            }
936    
937            public Layout fetchByUUID_G(String uuid, long groupId,
938                    boolean retrieveFromCache) throws SystemException {
939                    Object[] finderArgs = new Object[] { uuid, groupId };
940    
941                    Object result = null;
942    
943                    if (retrieveFromCache) {
944                            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_UUID_G,
945                                            finderArgs, this);
946                    }
947    
948                    if (result == null) {
949                            Session session = null;
950    
951                            try {
952                                    session = openSession();
953    
954                                    StringBundler query = new StringBundler(4);
955    
956                                    query.append(_SQL_SELECT_LAYOUT_WHERE);
957    
958                                    if (uuid == null) {
959                                            query.append(_FINDER_COLUMN_UUID_G_UUID_1);
960                                    }
961                                    else {
962                                            if (uuid.equals(StringPool.BLANK)) {
963                                                    query.append(_FINDER_COLUMN_UUID_G_UUID_3);
964                                            }
965                                            else {
966                                                    query.append(_FINDER_COLUMN_UUID_G_UUID_2);
967                                            }
968                                    }
969    
970                                    query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
971    
972                                    query.append(LayoutModelImpl.ORDER_BY_JPQL);
973    
974                                    String sql = query.toString();
975    
976                                    Query q = session.createQuery(sql);
977    
978                                    QueryPos qPos = QueryPos.getInstance(q);
979    
980                                    if (uuid != null) {
981                                            qPos.add(uuid);
982                                    }
983    
984                                    qPos.add(groupId);
985    
986                                    List<Layout> list = q.list();
987    
988                                    result = list;
989    
990                                    Layout layout = null;
991    
992                                    if (list.isEmpty()) {
993                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
994                                                    finderArgs, list);
995                                    }
996                                    else {
997                                            layout = list.get(0);
998    
999                                            cacheResult(layout);
1000    
1001                                            if ((layout.getUuid() == null) ||
1002                                                            !layout.getUuid().equals(uuid) ||
1003                                                            (layout.getGroupId() != groupId)) {
1004                                                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
1005                                                            finderArgs, layout);
1006                                            }
1007                                    }
1008    
1009                                    return layout;
1010                            }
1011                            catch (Exception e) {
1012                                    throw processException(e);
1013                            }
1014                            finally {
1015                                    if (result == null) {
1016                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
1017                                                    finderArgs, new ArrayList<Layout>());
1018                                    }
1019    
1020                                    closeSession(session);
1021                            }
1022                    }
1023                    else {
1024                            if (result instanceof List<?>) {
1025                                    return null;
1026                            }
1027                            else {
1028                                    return (Layout)result;
1029                            }
1030                    }
1031            }
1032    
1033            public List<Layout> findByGroupId(long groupId) throws SystemException {
1034                    return findByGroupId(groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1035            }
1036    
1037            public List<Layout> findByGroupId(long groupId, int start, int end)
1038                    throws SystemException {
1039                    return findByGroupId(groupId, start, end, null);
1040            }
1041    
1042            public List<Layout> findByGroupId(long groupId, int start, int end,
1043                    OrderByComparator orderByComparator) throws SystemException {
1044                    Object[] finderArgs = new Object[] {
1045                                    groupId,
1046                                    
1047                                    String.valueOf(start), String.valueOf(end),
1048                                    String.valueOf(orderByComparator)
1049                            };
1050    
1051                    List<Layout> list = (List<Layout>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_GROUPID,
1052                                    finderArgs, this);
1053    
1054                    if (list == null) {
1055                            Session session = null;
1056    
1057                            try {
1058                                    session = openSession();
1059    
1060                                    StringBundler query = null;
1061    
1062                                    if (orderByComparator != null) {
1063                                            query = new StringBundler(3 +
1064                                                            (orderByComparator.getOrderByFields().length * 3));
1065                                    }
1066                                    else {
1067                                            query = new StringBundler(3);
1068                                    }
1069    
1070                                    query.append(_SQL_SELECT_LAYOUT_WHERE);
1071    
1072                                    query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1073    
1074                                    if (orderByComparator != null) {
1075                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1076                                                    orderByComparator);
1077                                    }
1078    
1079                                    else {
1080                                            query.append(LayoutModelImpl.ORDER_BY_JPQL);
1081                                    }
1082    
1083                                    String sql = query.toString();
1084    
1085                                    Query q = session.createQuery(sql);
1086    
1087                                    QueryPos qPos = QueryPos.getInstance(q);
1088    
1089                                    qPos.add(groupId);
1090    
1091                                    list = (List<Layout>)QueryUtil.list(q, getDialect(), start, end);
1092                            }
1093                            catch (Exception e) {
1094                                    throw processException(e);
1095                            }
1096                            finally {
1097                                    if (list == null) {
1098                                            list = new ArrayList<Layout>();
1099                                    }
1100    
1101                                    cacheResult(list);
1102    
1103                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_GROUPID,
1104                                            finderArgs, list);
1105    
1106                                    closeSession(session);
1107                            }
1108                    }
1109    
1110                    return list;
1111            }
1112    
1113            public Layout findByGroupId_First(long groupId,
1114                    OrderByComparator orderByComparator)
1115                    throws NoSuchLayoutException, SystemException {
1116                    List<Layout> list = findByGroupId(groupId, 0, 1, orderByComparator);
1117    
1118                    if (list.isEmpty()) {
1119                            StringBundler msg = new StringBundler(4);
1120    
1121                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1122    
1123                            msg.append("groupId=");
1124                            msg.append(groupId);
1125    
1126                            msg.append(StringPool.CLOSE_CURLY_BRACE);
1127    
1128                            throw new NoSuchLayoutException(msg.toString());
1129                    }
1130                    else {
1131                            return list.get(0);
1132                    }
1133            }
1134    
1135            public Layout findByGroupId_Last(long groupId,
1136                    OrderByComparator orderByComparator)
1137                    throws NoSuchLayoutException, SystemException {
1138                    int count = countByGroupId(groupId);
1139    
1140                    List<Layout> list = findByGroupId(groupId, count - 1, count,
1141                                    orderByComparator);
1142    
1143                    if (list.isEmpty()) {
1144                            StringBundler msg = new StringBundler(4);
1145    
1146                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1147    
1148                            msg.append("groupId=");
1149                            msg.append(groupId);
1150    
1151                            msg.append(StringPool.CLOSE_CURLY_BRACE);
1152    
1153                            throw new NoSuchLayoutException(msg.toString());
1154                    }
1155                    else {
1156                            return list.get(0);
1157                    }
1158            }
1159    
1160            public Layout[] findByGroupId_PrevAndNext(long plid, long groupId,
1161                    OrderByComparator orderByComparator)
1162                    throws NoSuchLayoutException, SystemException {
1163                    Layout layout = findByPrimaryKey(plid);
1164    
1165                    Session session = null;
1166    
1167                    try {
1168                            session = openSession();
1169    
1170                            Layout[] array = new LayoutImpl[3];
1171    
1172                            array[0] = getByGroupId_PrevAndNext(session, layout, groupId,
1173                                            orderByComparator, true);
1174    
1175                            array[1] = layout;
1176    
1177                            array[2] = getByGroupId_PrevAndNext(session, layout, groupId,
1178                                            orderByComparator, false);
1179    
1180                            return array;
1181                    }
1182                    catch (Exception e) {
1183                            throw processException(e);
1184                    }
1185                    finally {
1186                            closeSession(session);
1187                    }
1188            }
1189    
1190            protected Layout getByGroupId_PrevAndNext(Session session, Layout layout,
1191                    long groupId, OrderByComparator orderByComparator, boolean previous) {
1192                    StringBundler query = null;
1193    
1194                    if (orderByComparator != null) {
1195                            query = new StringBundler(6 +
1196                                            (orderByComparator.getOrderByFields().length * 6));
1197                    }
1198                    else {
1199                            query = new StringBundler(3);
1200                    }
1201    
1202                    query.append(_SQL_SELECT_LAYOUT_WHERE);
1203    
1204                    query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1205    
1206                    if (orderByComparator != null) {
1207                            String[] orderByFields = orderByComparator.getOrderByFields();
1208    
1209                            if (orderByFields.length > 0) {
1210                                    query.append(WHERE_AND);
1211                            }
1212    
1213                            for (int i = 0; i < orderByFields.length; i++) {
1214                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1215                                    query.append(orderByFields[i]);
1216    
1217                                    if ((i + 1) < orderByFields.length) {
1218                                            if (orderByComparator.isAscending() ^ previous) {
1219                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
1220                                            }
1221                                            else {
1222                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
1223                                            }
1224                                    }
1225                                    else {
1226                                            if (orderByComparator.isAscending() ^ previous) {
1227                                                    query.append(WHERE_GREATER_THAN);
1228                                            }
1229                                            else {
1230                                                    query.append(WHERE_LESSER_THAN);
1231                                            }
1232                                    }
1233                            }
1234    
1235                            query.append(ORDER_BY_CLAUSE);
1236    
1237                            for (int i = 0; i < orderByFields.length; i++) {
1238                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1239                                    query.append(orderByFields[i]);
1240    
1241                                    if ((i + 1) < orderByFields.length) {
1242                                            if (orderByComparator.isAscending() ^ previous) {
1243                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
1244                                            }
1245                                            else {
1246                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
1247                                            }
1248                                    }
1249                                    else {
1250                                            if (orderByComparator.isAscending() ^ previous) {
1251                                                    query.append(ORDER_BY_ASC);
1252                                            }
1253                                            else {
1254                                                    query.append(ORDER_BY_DESC);
1255                                            }
1256                                    }
1257                            }
1258                    }
1259    
1260                    else {
1261                            query.append(LayoutModelImpl.ORDER_BY_JPQL);
1262                    }
1263    
1264                    String sql = query.toString();
1265    
1266                    Query q = session.createQuery(sql);
1267    
1268                    q.setFirstResult(0);
1269                    q.setMaxResults(2);
1270    
1271                    QueryPos qPos = QueryPos.getInstance(q);
1272    
1273                    qPos.add(groupId);
1274    
1275                    if (orderByComparator != null) {
1276                            Object[] values = orderByComparator.getOrderByValues(layout);
1277    
1278                            for (Object value : values) {
1279                                    qPos.add(value);
1280                            }
1281                    }
1282    
1283                    List<Layout> list = q.list();
1284    
1285                    if (list.size() == 2) {
1286                            return list.get(1);
1287                    }
1288                    else {
1289                            return null;
1290                    }
1291            }
1292    
1293            public List<Layout> findByCompanyId(long companyId)
1294                    throws SystemException {
1295                    return findByCompanyId(companyId, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
1296                            null);
1297            }
1298    
1299            public List<Layout> findByCompanyId(long companyId, int start, int end)
1300                    throws SystemException {
1301                    return findByCompanyId(companyId, start, end, null);
1302            }
1303    
1304            public List<Layout> findByCompanyId(long companyId, int start, int end,
1305                    OrderByComparator orderByComparator) throws SystemException {
1306                    Object[] finderArgs = new Object[] {
1307                                    companyId,
1308                                    
1309                                    String.valueOf(start), String.valueOf(end),
1310                                    String.valueOf(orderByComparator)
1311                            };
1312    
1313                    List<Layout> list = (List<Layout>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_COMPANYID,
1314                                    finderArgs, this);
1315    
1316                    if (list == null) {
1317                            Session session = null;
1318    
1319                            try {
1320                                    session = openSession();
1321    
1322                                    StringBundler query = null;
1323    
1324                                    if (orderByComparator != null) {
1325                                            query = new StringBundler(3 +
1326                                                            (orderByComparator.getOrderByFields().length * 3));
1327                                    }
1328                                    else {
1329                                            query = new StringBundler(3);
1330                                    }
1331    
1332                                    query.append(_SQL_SELECT_LAYOUT_WHERE);
1333    
1334                                    query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
1335    
1336                                    if (orderByComparator != null) {
1337                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1338                                                    orderByComparator);
1339                                    }
1340    
1341                                    else {
1342                                            query.append(LayoutModelImpl.ORDER_BY_JPQL);
1343                                    }
1344    
1345                                    String sql = query.toString();
1346    
1347                                    Query q = session.createQuery(sql);
1348    
1349                                    QueryPos qPos = QueryPos.getInstance(q);
1350    
1351                                    qPos.add(companyId);
1352    
1353                                    list = (List<Layout>)QueryUtil.list(q, getDialect(), start, end);
1354                            }
1355                            catch (Exception e) {
1356                                    throw processException(e);
1357                            }
1358                            finally {
1359                                    if (list == null) {
1360                                            list = new ArrayList<Layout>();
1361                                    }
1362    
1363                                    cacheResult(list);
1364    
1365                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_COMPANYID,
1366                                            finderArgs, list);
1367    
1368                                    closeSession(session);
1369                            }
1370                    }
1371    
1372                    return list;
1373            }
1374    
1375            public Layout findByCompanyId_First(long companyId,
1376                    OrderByComparator orderByComparator)
1377                    throws NoSuchLayoutException, SystemException {
1378                    List<Layout> list = findByCompanyId(companyId, 0, 1, orderByComparator);
1379    
1380                    if (list.isEmpty()) {
1381                            StringBundler msg = new StringBundler(4);
1382    
1383                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1384    
1385                            msg.append("companyId=");
1386                            msg.append(companyId);
1387    
1388                            msg.append(StringPool.CLOSE_CURLY_BRACE);
1389    
1390                            throw new NoSuchLayoutException(msg.toString());
1391                    }
1392                    else {
1393                            return list.get(0);
1394                    }
1395            }
1396    
1397            public Layout findByCompanyId_Last(long companyId,
1398                    OrderByComparator orderByComparator)
1399                    throws NoSuchLayoutException, SystemException {
1400                    int count = countByCompanyId(companyId);
1401    
1402                    List<Layout> list = findByCompanyId(companyId, count - 1, count,
1403                                    orderByComparator);
1404    
1405                    if (list.isEmpty()) {
1406                            StringBundler msg = new StringBundler(4);
1407    
1408                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1409    
1410                            msg.append("companyId=");
1411                            msg.append(companyId);
1412    
1413                            msg.append(StringPool.CLOSE_CURLY_BRACE);
1414    
1415                            throw new NoSuchLayoutException(msg.toString());
1416                    }
1417                    else {
1418                            return list.get(0);
1419                    }
1420            }
1421    
1422            public Layout[] findByCompanyId_PrevAndNext(long plid, long companyId,
1423                    OrderByComparator orderByComparator)
1424                    throws NoSuchLayoutException, SystemException {
1425                    Layout layout = findByPrimaryKey(plid);
1426    
1427                    Session session = null;
1428    
1429                    try {
1430                            session = openSession();
1431    
1432                            Layout[] array = new LayoutImpl[3];
1433    
1434                            array[0] = getByCompanyId_PrevAndNext(session, layout, companyId,
1435                                            orderByComparator, true);
1436    
1437                            array[1] = layout;
1438    
1439                            array[2] = getByCompanyId_PrevAndNext(session, layout, companyId,
1440                                            orderByComparator, false);
1441    
1442                            return array;
1443                    }
1444                    catch (Exception e) {
1445                            throw processException(e);
1446                    }
1447                    finally {
1448                            closeSession(session);
1449                    }
1450            }
1451    
1452            protected Layout getByCompanyId_PrevAndNext(Session session, Layout layout,
1453                    long companyId, OrderByComparator orderByComparator, boolean previous) {
1454                    StringBundler query = null;
1455    
1456                    if (orderByComparator != null) {
1457                            query = new StringBundler(6 +
1458                                            (orderByComparator.getOrderByFields().length * 6));
1459                    }
1460                    else {
1461                            query = new StringBundler(3);
1462                    }
1463    
1464                    query.append(_SQL_SELECT_LAYOUT_WHERE);
1465    
1466                    query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
1467    
1468                    if (orderByComparator != null) {
1469                            String[] orderByFields = orderByComparator.getOrderByFields();
1470    
1471                            if (orderByFields.length > 0) {
1472                                    query.append(WHERE_AND);
1473                            }
1474    
1475                            for (int i = 0; i < orderByFields.length; i++) {
1476                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1477                                    query.append(orderByFields[i]);
1478    
1479                                    if ((i + 1) < orderByFields.length) {
1480                                            if (orderByComparator.isAscending() ^ previous) {
1481                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
1482                                            }
1483                                            else {
1484                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
1485                                            }
1486                                    }
1487                                    else {
1488                                            if (orderByComparator.isAscending() ^ previous) {
1489                                                    query.append(WHERE_GREATER_THAN);
1490                                            }
1491                                            else {
1492                                                    query.append(WHERE_LESSER_THAN);
1493                                            }
1494                                    }
1495                            }
1496    
1497                            query.append(ORDER_BY_CLAUSE);
1498    
1499                            for (int i = 0; i < orderByFields.length; i++) {
1500                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1501                                    query.append(orderByFields[i]);
1502    
1503                                    if ((i + 1) < orderByFields.length) {
1504                                            if (orderByComparator.isAscending() ^ previous) {
1505                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
1506                                            }
1507                                            else {
1508                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
1509                                            }
1510                                    }
1511                                    else {
1512                                            if (orderByComparator.isAscending() ^ previous) {
1513                                                    query.append(ORDER_BY_ASC);
1514                                            }
1515                                            else {
1516                                                    query.append(ORDER_BY_DESC);
1517                                            }
1518                                    }
1519                            }
1520                    }
1521    
1522                    else {
1523                            query.append(LayoutModelImpl.ORDER_BY_JPQL);
1524                    }
1525    
1526                    String sql = query.toString();
1527    
1528                    Query q = session.createQuery(sql);
1529    
1530                    q.setFirstResult(0);
1531                    q.setMaxResults(2);
1532    
1533                    QueryPos qPos = QueryPos.getInstance(q);
1534    
1535                    qPos.add(companyId);
1536    
1537                    if (orderByComparator != null) {
1538                            Object[] values = orderByComparator.getOrderByValues(layout);
1539    
1540                            for (Object value : values) {
1541                                    qPos.add(value);
1542                            }
1543                    }
1544    
1545                    List<Layout> list = q.list();
1546    
1547                    if (list.size() == 2) {
1548                            return list.get(1);
1549                    }
1550                    else {
1551                            return null;
1552                    }
1553            }
1554    
1555            public Layout findByDLFolderId(long dlFolderId)
1556                    throws NoSuchLayoutException, SystemException {
1557                    Layout layout = fetchByDLFolderId(dlFolderId);
1558    
1559                    if (layout == null) {
1560                            StringBundler msg = new StringBundler(4);
1561    
1562                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1563    
1564                            msg.append("dlFolderId=");
1565                            msg.append(dlFolderId);
1566    
1567                            msg.append(StringPool.CLOSE_CURLY_BRACE);
1568    
1569                            if (_log.isWarnEnabled()) {
1570                                    _log.warn(msg.toString());
1571                            }
1572    
1573                            throw new NoSuchLayoutException(msg.toString());
1574                    }
1575    
1576                    return layout;
1577            }
1578    
1579            public Layout fetchByDLFolderId(long dlFolderId) throws SystemException {
1580                    return fetchByDLFolderId(dlFolderId, true);
1581            }
1582    
1583            public Layout fetchByDLFolderId(long dlFolderId, boolean retrieveFromCache)
1584                    throws SystemException {
1585                    Object[] finderArgs = new Object[] { dlFolderId };
1586    
1587                    Object result = null;
1588    
1589                    if (retrieveFromCache) {
1590                            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_DLFOLDERID,
1591                                            finderArgs, this);
1592                    }
1593    
1594                    if (result == null) {
1595                            Session session = null;
1596    
1597                            try {
1598                                    session = openSession();
1599    
1600                                    StringBundler query = new StringBundler(3);
1601    
1602                                    query.append(_SQL_SELECT_LAYOUT_WHERE);
1603    
1604                                    query.append(_FINDER_COLUMN_DLFOLDERID_DLFOLDERID_2);
1605    
1606                                    query.append(LayoutModelImpl.ORDER_BY_JPQL);
1607    
1608                                    String sql = query.toString();
1609    
1610                                    Query q = session.createQuery(sql);
1611    
1612                                    QueryPos qPos = QueryPos.getInstance(q);
1613    
1614                                    qPos.add(dlFolderId);
1615    
1616                                    List<Layout> list = q.list();
1617    
1618                                    result = list;
1619    
1620                                    Layout layout = null;
1621    
1622                                    if (list.isEmpty()) {
1623                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_DLFOLDERID,
1624                                                    finderArgs, list);
1625                                    }
1626                                    else {
1627                                            layout = list.get(0);
1628    
1629                                            cacheResult(layout);
1630    
1631                                            if ((layout.getDlFolderId() != dlFolderId)) {
1632                                                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_DLFOLDERID,
1633                                                            finderArgs, layout);
1634                                            }
1635                                    }
1636    
1637                                    return layout;
1638                            }
1639                            catch (Exception e) {
1640                                    throw processException(e);
1641                            }
1642                            finally {
1643                                    if (result == null) {
1644                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_DLFOLDERID,
1645                                                    finderArgs, new ArrayList<Layout>());
1646                                    }
1647    
1648                                    closeSession(session);
1649                            }
1650                    }
1651                    else {
1652                            if (result instanceof List<?>) {
1653                                    return null;
1654                            }
1655                            else {
1656                                    return (Layout)result;
1657                            }
1658                    }
1659            }
1660    
1661            public Layout findByIconImageId(long iconImageId)
1662                    throws NoSuchLayoutException, SystemException {
1663                    Layout layout = fetchByIconImageId(iconImageId);
1664    
1665                    if (layout == null) {
1666                            StringBundler msg = new StringBundler(4);
1667    
1668                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1669    
1670                            msg.append("iconImageId=");
1671                            msg.append(iconImageId);
1672    
1673                            msg.append(StringPool.CLOSE_CURLY_BRACE);
1674    
1675                            if (_log.isWarnEnabled()) {
1676                                    _log.warn(msg.toString());
1677                            }
1678    
1679                            throw new NoSuchLayoutException(msg.toString());
1680                    }
1681    
1682                    return layout;
1683            }
1684    
1685            public Layout fetchByIconImageId(long iconImageId)
1686                    throws SystemException {
1687                    return fetchByIconImageId(iconImageId, true);
1688            }
1689    
1690            public Layout fetchByIconImageId(long iconImageId, boolean retrieveFromCache)
1691                    throws SystemException {
1692                    Object[] finderArgs = new Object[] { iconImageId };
1693    
1694                    Object result = null;
1695    
1696                    if (retrieveFromCache) {
1697                            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_ICONIMAGEID,
1698                                            finderArgs, this);
1699                    }
1700    
1701                    if (result == null) {
1702                            Session session = null;
1703    
1704                            try {
1705                                    session = openSession();
1706    
1707                                    StringBundler query = new StringBundler(3);
1708    
1709                                    query.append(_SQL_SELECT_LAYOUT_WHERE);
1710    
1711                                    query.append(_FINDER_COLUMN_ICONIMAGEID_ICONIMAGEID_2);
1712    
1713                                    query.append(LayoutModelImpl.ORDER_BY_JPQL);
1714    
1715                                    String sql = query.toString();
1716    
1717                                    Query q = session.createQuery(sql);
1718    
1719                                    QueryPos qPos = QueryPos.getInstance(q);
1720    
1721                                    qPos.add(iconImageId);
1722    
1723                                    List<Layout> list = q.list();
1724    
1725                                    result = list;
1726    
1727                                    Layout layout = null;
1728    
1729                                    if (list.isEmpty()) {
1730                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_ICONIMAGEID,
1731                                                    finderArgs, list);
1732                                    }
1733                                    else {
1734                                            layout = list.get(0);
1735    
1736                                            cacheResult(layout);
1737    
1738                                            if ((layout.getIconImageId() != iconImageId)) {
1739                                                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_ICONIMAGEID,
1740                                                            finderArgs, layout);
1741                                            }
1742                                    }
1743    
1744                                    return layout;
1745                            }
1746                            catch (Exception e) {
1747                                    throw processException(e);
1748                            }
1749                            finally {
1750                                    if (result == null) {
1751                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_ICONIMAGEID,
1752                                                    finderArgs, new ArrayList<Layout>());
1753                                    }
1754    
1755                                    closeSession(session);
1756                            }
1757                    }
1758                    else {
1759                            if (result instanceof List<?>) {
1760                                    return null;
1761                            }
1762                            else {
1763                                    return (Layout)result;
1764                            }
1765                    }
1766            }
1767    
1768            public List<Layout> findByG_P(long groupId, boolean privateLayout)
1769                    throws SystemException {
1770                    return findByG_P(groupId, privateLayout, QueryUtil.ALL_POS,
1771                            QueryUtil.ALL_POS, null);
1772            }
1773    
1774            public List<Layout> findByG_P(long groupId, boolean privateLayout,
1775                    int start, int end) throws SystemException {
1776                    return findByG_P(groupId, privateLayout, start, end, null);
1777            }
1778    
1779            public List<Layout> findByG_P(long groupId, boolean privateLayout,
1780                    int start, int end, OrderByComparator orderByComparator)
1781                    throws SystemException {
1782                    Object[] finderArgs = new Object[] {
1783                                    groupId, privateLayout,
1784                                    
1785                                    String.valueOf(start), String.valueOf(end),
1786                                    String.valueOf(orderByComparator)
1787                            };
1788    
1789                    List<Layout> list = (List<Layout>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_P,
1790                                    finderArgs, this);
1791    
1792                    if (list == null) {
1793                            Session session = null;
1794    
1795                            try {
1796                                    session = openSession();
1797    
1798                                    StringBundler query = null;
1799    
1800                                    if (orderByComparator != null) {
1801                                            query = new StringBundler(4 +
1802                                                            (orderByComparator.getOrderByFields().length * 3));
1803                                    }
1804                                    else {
1805                                            query = new StringBundler(4);
1806                                    }
1807    
1808                                    query.append(_SQL_SELECT_LAYOUT_WHERE);
1809    
1810                                    query.append(_FINDER_COLUMN_G_P_GROUPID_2);
1811    
1812                                    query.append(_FINDER_COLUMN_G_P_PRIVATELAYOUT_2);
1813    
1814                                    if (orderByComparator != null) {
1815                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1816                                                    orderByComparator);
1817                                    }
1818    
1819                                    else {
1820                                            query.append(LayoutModelImpl.ORDER_BY_JPQL);
1821                                    }
1822    
1823                                    String sql = query.toString();
1824    
1825                                    Query q = session.createQuery(sql);
1826    
1827                                    QueryPos qPos = QueryPos.getInstance(q);
1828    
1829                                    qPos.add(groupId);
1830    
1831                                    qPos.add(privateLayout);
1832    
1833                                    list = (List<Layout>)QueryUtil.list(q, getDialect(), start, end);
1834                            }
1835                            catch (Exception e) {
1836                                    throw processException(e);
1837                            }
1838                            finally {
1839                                    if (list == null) {
1840                                            list = new ArrayList<Layout>();
1841                                    }
1842    
1843                                    cacheResult(list);
1844    
1845                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_P, finderArgs,
1846                                            list);
1847    
1848                                    closeSession(session);
1849                            }
1850                    }
1851    
1852                    return list;
1853            }
1854    
1855            public Layout findByG_P_First(long groupId, boolean privateLayout,
1856                    OrderByComparator orderByComparator)
1857                    throws NoSuchLayoutException, SystemException {
1858                    List<Layout> list = findByG_P(groupId, privateLayout, 0, 1,
1859                                    orderByComparator);
1860    
1861                    if (list.isEmpty()) {
1862                            StringBundler msg = new StringBundler(6);
1863    
1864                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1865    
1866                            msg.append("groupId=");
1867                            msg.append(groupId);
1868    
1869                            msg.append(", privateLayout=");
1870                            msg.append(privateLayout);
1871    
1872                            msg.append(StringPool.CLOSE_CURLY_BRACE);
1873    
1874                            throw new NoSuchLayoutException(msg.toString());
1875                    }
1876                    else {
1877                            return list.get(0);
1878                    }
1879            }
1880    
1881            public Layout findByG_P_Last(long groupId, boolean privateLayout,
1882                    OrderByComparator orderByComparator)
1883                    throws NoSuchLayoutException, SystemException {
1884                    int count = countByG_P(groupId, privateLayout);
1885    
1886                    List<Layout> list = findByG_P(groupId, privateLayout, count - 1, count,
1887                                    orderByComparator);
1888    
1889                    if (list.isEmpty()) {
1890                            StringBundler msg = new StringBundler(6);
1891    
1892                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1893    
1894                            msg.append("groupId=");
1895                            msg.append(groupId);
1896    
1897                            msg.append(", privateLayout=");
1898                            msg.append(privateLayout);
1899    
1900                            msg.append(StringPool.CLOSE_CURLY_BRACE);
1901    
1902                            throw new NoSuchLayoutException(msg.toString());
1903                    }
1904                    else {
1905                            return list.get(0);
1906                    }
1907            }
1908    
1909            public Layout[] findByG_P_PrevAndNext(long plid, long groupId,
1910                    boolean privateLayout, OrderByComparator orderByComparator)
1911                    throws NoSuchLayoutException, SystemException {
1912                    Layout layout = findByPrimaryKey(plid);
1913    
1914                    Session session = null;
1915    
1916                    try {
1917                            session = openSession();
1918    
1919                            Layout[] array = new LayoutImpl[3];
1920    
1921                            array[0] = getByG_P_PrevAndNext(session, layout, groupId,
1922                                            privateLayout, orderByComparator, true);
1923    
1924                            array[1] = layout;
1925    
1926                            array[2] = getByG_P_PrevAndNext(session, layout, groupId,
1927                                            privateLayout, orderByComparator, false);
1928    
1929                            return array;
1930                    }
1931                    catch (Exception e) {
1932                            throw processException(e);
1933                    }
1934                    finally {
1935                            closeSession(session);
1936                    }
1937            }
1938    
1939            protected Layout getByG_P_PrevAndNext(Session session, Layout layout,
1940                    long groupId, boolean privateLayout,
1941                    OrderByComparator orderByComparator, boolean previous) {
1942                    StringBundler query = null;
1943    
1944                    if (orderByComparator != null) {
1945                            query = new StringBundler(6 +
1946                                            (orderByComparator.getOrderByFields().length * 6));
1947                    }
1948                    else {
1949                            query = new StringBundler(3);
1950                    }
1951    
1952                    query.append(_SQL_SELECT_LAYOUT_WHERE);
1953    
1954                    query.append(_FINDER_COLUMN_G_P_GROUPID_2);
1955    
1956                    query.append(_FINDER_COLUMN_G_P_PRIVATELAYOUT_2);
1957    
1958                    if (orderByComparator != null) {
1959                            String[] orderByFields = orderByComparator.getOrderByFields();
1960    
1961                            if (orderByFields.length > 0) {
1962                                    query.append(WHERE_AND);
1963                            }
1964    
1965                            for (int i = 0; i < orderByFields.length; i++) {
1966                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1967                                    query.append(orderByFields[i]);
1968    
1969                                    if ((i + 1) < orderByFields.length) {
1970                                            if (orderByComparator.isAscending() ^ previous) {
1971                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
1972                                            }
1973                                            else {
1974                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
1975                                            }
1976                                    }
1977                                    else {
1978                                            if (orderByComparator.isAscending() ^ previous) {
1979                                                    query.append(WHERE_GREATER_THAN);
1980                                            }
1981                                            else {
1982                                                    query.append(WHERE_LESSER_THAN);
1983                                            }
1984                                    }
1985                            }
1986    
1987                            query.append(ORDER_BY_CLAUSE);
1988    
1989                            for (int i = 0; i < orderByFields.length; i++) {
1990                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1991                                    query.append(orderByFields[i]);
1992    
1993                                    if ((i + 1) < orderByFields.length) {
1994                                            if (orderByComparator.isAscending() ^ previous) {
1995                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
1996                                            }
1997                                            else {
1998                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
1999                                            }
2000                                    }
2001                                    else {
2002                                            if (orderByComparator.isAscending() ^ previous) {
2003                                                    query.append(ORDER_BY_ASC);
2004                                            }
2005                                            else {
2006                                                    query.append(ORDER_BY_DESC);
2007                                            }
2008                                    }
2009                            }
2010                    }
2011    
2012                    else {
2013                            query.append(LayoutModelImpl.ORDER_BY_JPQL);
2014                    }
2015    
2016                    String sql = query.toString();
2017    
2018                    Query q = session.createQuery(sql);
2019    
2020                    q.setFirstResult(0);
2021                    q.setMaxResults(2);
2022    
2023                    QueryPos qPos = QueryPos.getInstance(q);
2024    
2025                    qPos.add(groupId);
2026    
2027                    qPos.add(privateLayout);
2028    
2029                    if (orderByComparator != null) {
2030                            Object[] values = orderByComparator.getOrderByValues(layout);
2031    
2032                            for (Object value : values) {
2033                                    qPos.add(value);
2034                            }
2035                    }
2036    
2037                    List<Layout> list = q.list();
2038    
2039                    if (list.size() == 2) {
2040                            return list.get(1);
2041                    }
2042                    else {
2043                            return null;
2044                    }
2045            }
2046    
2047            public Layout findByG_P_L(long groupId, boolean privateLayout, long layoutId)
2048                    throws NoSuchLayoutException, SystemException {
2049                    Layout layout = fetchByG_P_L(groupId, privateLayout, layoutId);
2050    
2051                    if (layout == null) {
2052                            StringBundler msg = new StringBundler(8);
2053    
2054                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2055    
2056                            msg.append("groupId=");
2057                            msg.append(groupId);
2058    
2059                            msg.append(", privateLayout=");
2060                            msg.append(privateLayout);
2061    
2062                            msg.append(", layoutId=");
2063                            msg.append(layoutId);
2064    
2065                            msg.append(StringPool.CLOSE_CURLY_BRACE);
2066    
2067                            if (_log.isWarnEnabled()) {
2068                                    _log.warn(msg.toString());
2069                            }
2070    
2071                            throw new NoSuchLayoutException(msg.toString());
2072                    }
2073    
2074                    return layout;
2075            }
2076    
2077            public Layout fetchByG_P_L(long groupId, boolean privateLayout,
2078                    long layoutId) throws SystemException {
2079                    return fetchByG_P_L(groupId, privateLayout, layoutId, true);
2080            }
2081    
2082            public Layout fetchByG_P_L(long groupId, boolean privateLayout,
2083                    long layoutId, boolean retrieveFromCache) throws SystemException {
2084                    Object[] finderArgs = new Object[] { groupId, privateLayout, layoutId };
2085    
2086                    Object result = null;
2087    
2088                    if (retrieveFromCache) {
2089                            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_G_P_L,
2090                                            finderArgs, this);
2091                    }
2092    
2093                    if (result == null) {
2094                            Session session = null;
2095    
2096                            try {
2097                                    session = openSession();
2098    
2099                                    StringBundler query = new StringBundler(5);
2100    
2101                                    query.append(_SQL_SELECT_LAYOUT_WHERE);
2102    
2103                                    query.append(_FINDER_COLUMN_G_P_L_GROUPID_2);
2104    
2105                                    query.append(_FINDER_COLUMN_G_P_L_PRIVATELAYOUT_2);
2106    
2107                                    query.append(_FINDER_COLUMN_G_P_L_LAYOUTID_2);
2108    
2109                                    query.append(LayoutModelImpl.ORDER_BY_JPQL);
2110    
2111                                    String sql = query.toString();
2112    
2113                                    Query q = session.createQuery(sql);
2114    
2115                                    QueryPos qPos = QueryPos.getInstance(q);
2116    
2117                                    qPos.add(groupId);
2118    
2119                                    qPos.add(privateLayout);
2120    
2121                                    qPos.add(layoutId);
2122    
2123                                    List<Layout> list = q.list();
2124    
2125                                    result = list;
2126    
2127                                    Layout layout = null;
2128    
2129                                    if (list.isEmpty()) {
2130                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_P_L,
2131                                                    finderArgs, list);
2132                                    }
2133                                    else {
2134                                            layout = list.get(0);
2135    
2136                                            cacheResult(layout);
2137    
2138                                            if ((layout.getGroupId() != groupId) ||
2139                                                            (layout.getPrivateLayout() != privateLayout) ||
2140                                                            (layout.getLayoutId() != layoutId)) {
2141                                                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_P_L,
2142                                                            finderArgs, layout);
2143                                            }
2144                                    }
2145    
2146                                    return layout;
2147                            }
2148                            catch (Exception e) {
2149                                    throw processException(e);
2150                            }
2151                            finally {
2152                                    if (result == null) {
2153                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_P_L,
2154                                                    finderArgs, new ArrayList<Layout>());
2155                                    }
2156    
2157                                    closeSession(session);
2158                            }
2159                    }
2160                    else {
2161                            if (result instanceof List<?>) {
2162                                    return null;
2163                            }
2164                            else {
2165                                    return (Layout)result;
2166                            }
2167                    }
2168            }
2169    
2170            public List<Layout> findByG_P_P(long groupId, boolean privateLayout,
2171                    long parentLayoutId) throws SystemException {
2172                    return findByG_P_P(groupId, privateLayout, parentLayoutId,
2173                            QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
2174            }
2175    
2176            public List<Layout> findByG_P_P(long groupId, boolean privateLayout,
2177                    long parentLayoutId, int start, int end) throws SystemException {
2178                    return findByG_P_P(groupId, privateLayout, parentLayoutId, start, end,
2179                            null);
2180            }
2181    
2182            public List<Layout> findByG_P_P(long groupId, boolean privateLayout,
2183                    long parentLayoutId, int start, int end,
2184                    OrderByComparator orderByComparator) throws SystemException {
2185                    Object[] finderArgs = new Object[] {
2186                                    groupId, privateLayout, parentLayoutId,
2187                                    
2188                                    String.valueOf(start), String.valueOf(end),
2189                                    String.valueOf(orderByComparator)
2190                            };
2191    
2192                    List<Layout> list = (List<Layout>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_P_P,
2193                                    finderArgs, this);
2194    
2195                    if (list == null) {
2196                            Session session = null;
2197    
2198                            try {
2199                                    session = openSession();
2200    
2201                                    StringBundler query = null;
2202    
2203                                    if (orderByComparator != null) {
2204                                            query = new StringBundler(5 +
2205                                                            (orderByComparator.getOrderByFields().length * 3));
2206                                    }
2207                                    else {
2208                                            query = new StringBundler(5);
2209                                    }
2210    
2211                                    query.append(_SQL_SELECT_LAYOUT_WHERE);
2212    
2213                                    query.append(_FINDER_COLUMN_G_P_P_GROUPID_2);
2214    
2215                                    query.append(_FINDER_COLUMN_G_P_P_PRIVATELAYOUT_2);
2216    
2217                                    query.append(_FINDER_COLUMN_G_P_P_PARENTLAYOUTID_2);
2218    
2219                                    if (orderByComparator != null) {
2220                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2221                                                    orderByComparator);
2222                                    }
2223    
2224                                    else {
2225                                            query.append(LayoutModelImpl.ORDER_BY_JPQL);
2226                                    }
2227    
2228                                    String sql = query.toString();
2229    
2230                                    Query q = session.createQuery(sql);
2231    
2232                                    QueryPos qPos = QueryPos.getInstance(q);
2233    
2234                                    qPos.add(groupId);
2235    
2236                                    qPos.add(privateLayout);
2237    
2238                                    qPos.add(parentLayoutId);
2239    
2240                                    list = (List<Layout>)QueryUtil.list(q, getDialect(), start, end);
2241                            }
2242                            catch (Exception e) {
2243                                    throw processException(e);
2244                            }
2245                            finally {
2246                                    if (list == null) {
2247                                            list = new ArrayList<Layout>();
2248                                    }
2249    
2250                                    cacheResult(list);
2251    
2252                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_P_P,
2253                                            finderArgs, list);
2254    
2255                                    closeSession(session);
2256                            }
2257                    }
2258    
2259                    return list;
2260            }
2261    
2262            public Layout findByG_P_P_First(long groupId, boolean privateLayout,
2263                    long parentLayoutId, OrderByComparator orderByComparator)
2264                    throws NoSuchLayoutException, SystemException {
2265                    List<Layout> list = findByG_P_P(groupId, privateLayout, parentLayoutId,
2266                                    0, 1, orderByComparator);
2267    
2268                    if (list.isEmpty()) {
2269                            StringBundler msg = new StringBundler(8);
2270    
2271                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2272    
2273                            msg.append("groupId=");
2274                            msg.append(groupId);
2275    
2276                            msg.append(", privateLayout=");
2277                            msg.append(privateLayout);
2278    
2279                            msg.append(", parentLayoutId=");
2280                            msg.append(parentLayoutId);
2281    
2282                            msg.append(StringPool.CLOSE_CURLY_BRACE);
2283    
2284                            throw new NoSuchLayoutException(msg.toString());
2285                    }
2286                    else {
2287                            return list.get(0);
2288                    }
2289            }
2290    
2291            public Layout findByG_P_P_Last(long groupId, boolean privateLayout,
2292                    long parentLayoutId, OrderByComparator orderByComparator)
2293                    throws NoSuchLayoutException, SystemException {
2294                    int count = countByG_P_P(groupId, privateLayout, parentLayoutId);
2295    
2296                    List<Layout> list = findByG_P_P(groupId, privateLayout, parentLayoutId,
2297                                    count - 1, count, orderByComparator);
2298    
2299                    if (list.isEmpty()) {
2300                            StringBundler msg = new StringBundler(8);
2301    
2302                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2303    
2304                            msg.append("groupId=");
2305                            msg.append(groupId);
2306    
2307                            msg.append(", privateLayout=");
2308                            msg.append(privateLayout);
2309    
2310                            msg.append(", parentLayoutId=");
2311                            msg.append(parentLayoutId);
2312    
2313                            msg.append(StringPool.CLOSE_CURLY_BRACE);
2314    
2315                            throw new NoSuchLayoutException(msg.toString());
2316                    }
2317                    else {
2318                            return list.get(0);
2319                    }
2320            }
2321    
2322            public Layout[] findByG_P_P_PrevAndNext(long plid, long groupId,
2323                    boolean privateLayout, long parentLayoutId,
2324                    OrderByComparator orderByComparator)
2325                    throws NoSuchLayoutException, SystemException {
2326                    Layout layout = findByPrimaryKey(plid);
2327    
2328                    Session session = null;
2329    
2330                    try {
2331                            session = openSession();
2332    
2333                            Layout[] array = new LayoutImpl[3];
2334    
2335                            array[0] = getByG_P_P_PrevAndNext(session, layout, groupId,
2336                                            privateLayout, parentLayoutId, orderByComparator, true);
2337    
2338                            array[1] = layout;
2339    
2340                            array[2] = getByG_P_P_PrevAndNext(session, layout, groupId,
2341                                            privateLayout, parentLayoutId, orderByComparator, false);
2342    
2343                            return array;
2344                    }
2345                    catch (Exception e) {
2346                            throw processException(e);
2347                    }
2348                    finally {
2349                            closeSession(session);
2350                    }
2351            }
2352    
2353            protected Layout getByG_P_P_PrevAndNext(Session session, Layout layout,
2354                    long groupId, boolean privateLayout, long parentLayoutId,
2355                    OrderByComparator orderByComparator, boolean previous) {
2356                    StringBundler query = null;
2357    
2358                    if (orderByComparator != null) {
2359                            query = new StringBundler(6 +
2360                                            (orderByComparator.getOrderByFields().length * 6));
2361                    }
2362                    else {
2363                            query = new StringBundler(3);
2364                    }
2365    
2366                    query.append(_SQL_SELECT_LAYOUT_WHERE);
2367    
2368                    query.append(_FINDER_COLUMN_G_P_P_GROUPID_2);
2369    
2370                    query.append(_FINDER_COLUMN_G_P_P_PRIVATELAYOUT_2);
2371    
2372                    query.append(_FINDER_COLUMN_G_P_P_PARENTLAYOUTID_2);
2373    
2374                    if (orderByComparator != null) {
2375                            String[] orderByFields = orderByComparator.getOrderByFields();
2376    
2377                            if (orderByFields.length > 0) {
2378                                    query.append(WHERE_AND);
2379                            }
2380    
2381                            for (int i = 0; i < orderByFields.length; i++) {
2382                                    query.append(_ORDER_BY_ENTITY_ALIAS);
2383                                    query.append(orderByFields[i]);
2384    
2385                                    if ((i + 1) < orderByFields.length) {
2386                                            if (orderByComparator.isAscending() ^ previous) {
2387                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
2388                                            }
2389                                            else {
2390                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
2391                                            }
2392                                    }
2393                                    else {
2394                                            if (orderByComparator.isAscending() ^ previous) {
2395                                                    query.append(WHERE_GREATER_THAN);
2396                                            }
2397                                            else {
2398                                                    query.append(WHERE_LESSER_THAN);
2399                                            }
2400                                    }
2401                            }
2402    
2403                            query.append(ORDER_BY_CLAUSE);
2404    
2405                            for (int i = 0; i < orderByFields.length; i++) {
2406                                    query.append(_ORDER_BY_ENTITY_ALIAS);
2407                                    query.append(orderByFields[i]);
2408    
2409                                    if ((i + 1) < orderByFields.length) {
2410                                            if (orderByComparator.isAscending() ^ previous) {
2411                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
2412                                            }
2413                                            else {
2414                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
2415                                            }
2416                                    }
2417                                    else {
2418                                            if (orderByComparator.isAscending() ^ previous) {
2419                                                    query.append(ORDER_BY_ASC);
2420                                            }
2421                                            else {
2422                                                    query.append(ORDER_BY_DESC);
2423                                            }
2424                                    }
2425                            }
2426                    }
2427    
2428                    else {
2429                            query.append(LayoutModelImpl.ORDER_BY_JPQL);
2430                    }
2431    
2432                    String sql = query.toString();
2433    
2434                    Query q = session.createQuery(sql);
2435    
2436                    q.setFirstResult(0);
2437                    q.setMaxResults(2);
2438    
2439                    QueryPos qPos = QueryPos.getInstance(q);
2440    
2441                    qPos.add(groupId);
2442    
2443                    qPos.add(privateLayout);
2444    
2445                    qPos.add(parentLayoutId);
2446    
2447                    if (orderByComparator != null) {
2448                            Object[] values = orderByComparator.getOrderByValues(layout);
2449    
2450                            for (Object value : values) {
2451                                    qPos.add(value);
2452                            }
2453                    }
2454    
2455                    List<Layout> list = q.list();
2456    
2457                    if (list.size() == 2) {
2458                            return list.get(1);
2459                    }
2460                    else {
2461                            return null;
2462                    }
2463            }
2464    
2465            public Layout findByG_P_F(long groupId, boolean privateLayout,
2466                    String friendlyURL) throws NoSuchLayoutException, SystemException {
2467                    Layout layout = fetchByG_P_F(groupId, privateLayout, friendlyURL);
2468    
2469                    if (layout == null) {
2470                            StringBundler msg = new StringBundler(8);
2471    
2472                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2473    
2474                            msg.append("groupId=");
2475                            msg.append(groupId);
2476    
2477                            msg.append(", privateLayout=");
2478                            msg.append(privateLayout);
2479    
2480                            msg.append(", friendlyURL=");
2481                            msg.append(friendlyURL);
2482    
2483                            msg.append(StringPool.CLOSE_CURLY_BRACE);
2484    
2485                            if (_log.isWarnEnabled()) {
2486                                    _log.warn(msg.toString());
2487                            }
2488    
2489                            throw new NoSuchLayoutException(msg.toString());
2490                    }
2491    
2492                    return layout;
2493            }
2494    
2495            public Layout fetchByG_P_F(long groupId, boolean privateLayout,
2496                    String friendlyURL) throws SystemException {
2497                    return fetchByG_P_F(groupId, privateLayout, friendlyURL, true);
2498            }
2499    
2500            public Layout fetchByG_P_F(long groupId, boolean privateLayout,
2501                    String friendlyURL, boolean retrieveFromCache)
2502                    throws SystemException {
2503                    Object[] finderArgs = new Object[] { groupId, privateLayout, friendlyURL };
2504    
2505                    Object result = null;
2506    
2507                    if (retrieveFromCache) {
2508                            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_G_P_F,
2509                                            finderArgs, this);
2510                    }
2511    
2512                    if (result == null) {
2513                            Session session = null;
2514    
2515                            try {
2516                                    session = openSession();
2517    
2518                                    StringBundler query = new StringBundler(5);
2519    
2520                                    query.append(_SQL_SELECT_LAYOUT_WHERE);
2521    
2522                                    query.append(_FINDER_COLUMN_G_P_F_GROUPID_2);
2523    
2524                                    query.append(_FINDER_COLUMN_G_P_F_PRIVATELAYOUT_2);
2525    
2526                                    if (friendlyURL == null) {
2527                                            query.append(_FINDER_COLUMN_G_P_F_FRIENDLYURL_1);
2528                                    }
2529                                    else {
2530                                            if (friendlyURL.equals(StringPool.BLANK)) {
2531                                                    query.append(_FINDER_COLUMN_G_P_F_FRIENDLYURL_3);
2532                                            }
2533                                            else {
2534                                                    query.append(_FINDER_COLUMN_G_P_F_FRIENDLYURL_2);
2535                                            }
2536                                    }
2537    
2538                                    query.append(LayoutModelImpl.ORDER_BY_JPQL);
2539    
2540                                    String sql = query.toString();
2541    
2542                                    Query q = session.createQuery(sql);
2543    
2544                                    QueryPos qPos = QueryPos.getInstance(q);
2545    
2546                                    qPos.add(groupId);
2547    
2548                                    qPos.add(privateLayout);
2549    
2550                                    if (friendlyURL != null) {
2551                                            qPos.add(friendlyURL);
2552                                    }
2553    
2554                                    List<Layout> list = q.list();
2555    
2556                                    result = list;
2557    
2558                                    Layout layout = null;
2559    
2560                                    if (list.isEmpty()) {
2561                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_P_F,
2562                                                    finderArgs, list);
2563                                    }
2564                                    else {
2565                                            layout = list.get(0);
2566    
2567                                            cacheResult(layout);
2568    
2569                                            if ((layout.getGroupId() != groupId) ||
2570                                                            (layout.getPrivateLayout() != privateLayout) ||
2571                                                            (layout.getFriendlyURL() == null) ||
2572                                                            !layout.getFriendlyURL().equals(friendlyURL)) {
2573                                                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_P_F,
2574                                                            finderArgs, layout);
2575                                            }
2576                                    }
2577    
2578                                    return layout;
2579                            }
2580                            catch (Exception e) {
2581                                    throw processException(e);
2582                            }
2583                            finally {
2584                                    if (result == null) {
2585                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_P_F,
2586                                                    finderArgs, new ArrayList<Layout>());
2587                                    }
2588    
2589                                    closeSession(session);
2590                            }
2591                    }
2592                    else {
2593                            if (result instanceof List<?>) {
2594                                    return null;
2595                            }
2596                            else {
2597                                    return (Layout)result;
2598                            }
2599                    }
2600            }
2601    
2602            public List<Layout> findByG_P_T(long groupId, boolean privateLayout,
2603                    String type) throws SystemException {
2604                    return findByG_P_T(groupId, privateLayout, type, QueryUtil.ALL_POS,
2605                            QueryUtil.ALL_POS, null);
2606            }
2607    
2608            public List<Layout> findByG_P_T(long groupId, boolean privateLayout,
2609                    String type, int start, int end) throws SystemException {
2610                    return findByG_P_T(groupId, privateLayout, type, start, end, null);
2611            }
2612    
2613            public List<Layout> findByG_P_T(long groupId, boolean privateLayout,
2614                    String type, int start, int end, OrderByComparator orderByComparator)
2615                    throws SystemException {
2616                    Object[] finderArgs = new Object[] {
2617                                    groupId, privateLayout, type,
2618                                    
2619                                    String.valueOf(start), String.valueOf(end),
2620                                    String.valueOf(orderByComparator)
2621                            };
2622    
2623                    List<Layout> list = (List<Layout>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_P_T,
2624                                    finderArgs, this);
2625    
2626                    if (list == null) {
2627                            Session session = null;
2628    
2629                            try {
2630                                    session = openSession();
2631    
2632                                    StringBundler query = null;
2633    
2634                                    if (orderByComparator != null) {
2635                                            query = new StringBundler(5 +
2636                                                            (orderByComparator.getOrderByFields().length * 3));
2637                                    }
2638                                    else {
2639                                            query = new StringBundler(5);
2640                                    }
2641    
2642                                    query.append(_SQL_SELECT_LAYOUT_WHERE);
2643    
2644                                    query.append(_FINDER_COLUMN_G_P_T_GROUPID_2);
2645    
2646                                    query.append(_FINDER_COLUMN_G_P_T_PRIVATELAYOUT_2);
2647    
2648                                    if (type == null) {
2649                                            query.append(_FINDER_COLUMN_G_P_T_TYPE_1);
2650                                    }
2651                                    else {
2652                                            if (type.equals(StringPool.BLANK)) {
2653                                                    query.append(_FINDER_COLUMN_G_P_T_TYPE_3);
2654                                            }
2655                                            else {
2656                                                    query.append(_FINDER_COLUMN_G_P_T_TYPE_2);
2657                                            }
2658                                    }
2659    
2660                                    if (orderByComparator != null) {
2661                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2662                                                    orderByComparator);
2663                                    }
2664    
2665                                    else {
2666                                            query.append(LayoutModelImpl.ORDER_BY_JPQL);
2667                                    }
2668    
2669                                    String sql = query.toString();
2670    
2671                                    Query q = session.createQuery(sql);
2672    
2673                                    QueryPos qPos = QueryPos.getInstance(q);
2674    
2675                                    qPos.add(groupId);
2676    
2677                                    qPos.add(privateLayout);
2678    
2679                                    if (type != null) {
2680                                            qPos.add(type);
2681                                    }
2682    
2683                                    list = (List<Layout>)QueryUtil.list(q, getDialect(), start, end);
2684                            }
2685                            catch (Exception e) {
2686                                    throw processException(e);
2687                            }
2688                            finally {
2689                                    if (list == null) {
2690                                            list = new ArrayList<Layout>();
2691                                    }
2692    
2693                                    cacheResult(list);
2694    
2695                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_P_T,
2696                                            finderArgs, list);
2697    
2698                                    closeSession(session);
2699                            }
2700                    }
2701    
2702                    return list;
2703            }
2704    
2705            public Layout findByG_P_T_First(long groupId, boolean privateLayout,
2706                    String type, OrderByComparator orderByComparator)
2707                    throws NoSuchLayoutException, SystemException {
2708                    List<Layout> list = findByG_P_T(groupId, privateLayout, type, 0, 1,
2709                                    orderByComparator);
2710    
2711                    if (list.isEmpty()) {
2712                            StringBundler msg = new StringBundler(8);
2713    
2714                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2715    
2716                            msg.append("groupId=");
2717                            msg.append(groupId);
2718    
2719                            msg.append(", privateLayout=");
2720                            msg.append(privateLayout);
2721    
2722                            msg.append(", type=");
2723                            msg.append(type);
2724    
2725                            msg.append(StringPool.CLOSE_CURLY_BRACE);
2726    
2727                            throw new NoSuchLayoutException(msg.toString());
2728                    }
2729                    else {
2730                            return list.get(0);
2731                    }
2732            }
2733    
2734            public Layout findByG_P_T_Last(long groupId, boolean privateLayout,
2735                    String type, OrderByComparator orderByComparator)
2736                    throws NoSuchLayoutException, SystemException {
2737                    int count = countByG_P_T(groupId, privateLayout, type);
2738    
2739                    List<Layout> list = findByG_P_T(groupId, privateLayout, type,
2740                                    count - 1, count, orderByComparator);
2741    
2742                    if (list.isEmpty()) {
2743                            StringBundler msg = new StringBundler(8);
2744    
2745                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2746    
2747                            msg.append("groupId=");
2748                            msg.append(groupId);
2749    
2750                            msg.append(", privateLayout=");
2751                            msg.append(privateLayout);
2752    
2753                            msg.append(", type=");
2754                            msg.append(type);
2755    
2756                            msg.append(StringPool.CLOSE_CURLY_BRACE);
2757    
2758                            throw new NoSuchLayoutException(msg.toString());
2759                    }
2760                    else {
2761                            return list.get(0);
2762                    }
2763            }
2764    
2765            public Layout[] findByG_P_T_PrevAndNext(long plid, long groupId,
2766                    boolean privateLayout, String type, OrderByComparator orderByComparator)
2767                    throws NoSuchLayoutException, SystemException {
2768                    Layout layout = findByPrimaryKey(plid);
2769    
2770                    Session session = null;
2771    
2772                    try {
2773                            session = openSession();
2774    
2775                            Layout[] array = new LayoutImpl[3];
2776    
2777                            array[0] = getByG_P_T_PrevAndNext(session, layout, groupId,
2778                                            privateLayout, type, orderByComparator, true);
2779    
2780                            array[1] = layout;
2781    
2782                            array[2] = getByG_P_T_PrevAndNext(session, layout, groupId,
2783                                            privateLayout, type, orderByComparator, false);
2784    
2785                            return array;
2786                    }
2787                    catch (Exception e) {
2788                            throw processException(e);
2789                    }
2790                    finally {
2791                            closeSession(session);
2792                    }
2793            }
2794    
2795            protected Layout getByG_P_T_PrevAndNext(Session session, Layout layout,
2796                    long groupId, boolean privateLayout, String type,
2797                    OrderByComparator orderByComparator, boolean previous) {
2798                    StringBundler query = null;
2799    
2800                    if (orderByComparator != null) {
2801                            query = new StringBundler(6 +
2802                                            (orderByComparator.getOrderByFields().length * 6));
2803                    }
2804                    else {
2805                            query = new StringBundler(3);
2806                    }
2807    
2808                    query.append(_SQL_SELECT_LAYOUT_WHERE);
2809    
2810                    query.append(_FINDER_COLUMN_G_P_T_GROUPID_2);
2811    
2812                    query.append(_FINDER_COLUMN_G_P_T_PRIVATELAYOUT_2);
2813    
2814                    if (type == null) {
2815                            query.append(_FINDER_COLUMN_G_P_T_TYPE_1);
2816                    }
2817                    else {
2818                            if (type.equals(StringPool.BLANK)) {
2819                                    query.append(_FINDER_COLUMN_G_P_T_TYPE_3);
2820                            }
2821                            else {
2822                                    query.append(_FINDER_COLUMN_G_P_T_TYPE_2);
2823                            }
2824                    }
2825    
2826                    if (orderByComparator != null) {
2827                            String[] orderByFields = orderByComparator.getOrderByFields();
2828    
2829                            if (orderByFields.length > 0) {
2830                                    query.append(WHERE_AND);
2831                            }
2832    
2833                            for (int i = 0; i < orderByFields.length; i++) {
2834                                    query.append(_ORDER_BY_ENTITY_ALIAS);
2835                                    query.append(orderByFields[i]);
2836    
2837                                    if ((i + 1) < orderByFields.length) {
2838                                            if (orderByComparator.isAscending() ^ previous) {
2839                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
2840                                            }
2841                                            else {
2842                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
2843                                            }
2844                                    }
2845                                    else {
2846                                            if (orderByComparator.isAscending() ^ previous) {
2847                                                    query.append(WHERE_GREATER_THAN);
2848                                            }
2849                                            else {
2850                                                    query.append(WHERE_LESSER_THAN);
2851                                            }
2852                                    }
2853                            }
2854    
2855                            query.append(ORDER_BY_CLAUSE);
2856    
2857                            for (int i = 0; i < orderByFields.length; i++) {
2858                                    query.append(_ORDER_BY_ENTITY_ALIAS);
2859                                    query.append(orderByFields[i]);
2860    
2861                                    if ((i + 1) < orderByFields.length) {
2862                                            if (orderByComparator.isAscending() ^ previous) {
2863                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
2864                                            }
2865                                            else {
2866                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
2867                                            }
2868                                    }
2869                                    else {
2870                                            if (orderByComparator.isAscending() ^ previous) {
2871                                                    query.append(ORDER_BY_ASC);
2872                                            }
2873                                            else {
2874                                                    query.append(ORDER_BY_DESC);
2875                                            }
2876                                    }
2877                            }
2878                    }
2879    
2880                    else {
2881                            query.append(LayoutModelImpl.ORDER_BY_JPQL);
2882                    }
2883    
2884                    String sql = query.toString();
2885    
2886                    Query q = session.createQuery(sql);
2887    
2888                    q.setFirstResult(0);
2889                    q.setMaxResults(2);
2890    
2891                    QueryPos qPos = QueryPos.getInstance(q);
2892    
2893                    qPos.add(groupId);
2894    
2895                    qPos.add(privateLayout);
2896    
2897                    if (type != null) {
2898                            qPos.add(type);
2899                    }
2900    
2901                    if (orderByComparator != null) {
2902                            Object[] values = orderByComparator.getOrderByValues(layout);
2903    
2904                            for (Object value : values) {
2905                                    qPos.add(value);
2906                            }
2907                    }
2908    
2909                    List<Layout> list = q.list();
2910    
2911                    if (list.size() == 2) {
2912                            return list.get(1);
2913                    }
2914                    else {
2915                            return null;
2916                    }
2917            }
2918    
2919            public List<Layout> findAll() throws SystemException {
2920                    return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
2921            }
2922    
2923            public List<Layout> findAll(int start, int end) throws SystemException {
2924                    return findAll(start, end, null);
2925            }
2926    
2927            public List<Layout> findAll(int start, int end,
2928                    OrderByComparator orderByComparator) throws SystemException {
2929                    Object[] finderArgs = new Object[] {
2930                                    String.valueOf(start), String.valueOf(end),
2931                                    String.valueOf(orderByComparator)
2932                            };
2933    
2934                    List<Layout> list = (List<Layout>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
2935                                    finderArgs, this);
2936    
2937                    if (list == null) {
2938                            Session session = null;
2939    
2940                            try {
2941                                    session = openSession();
2942    
2943                                    StringBundler query = null;
2944                                    String sql = null;
2945    
2946                                    if (orderByComparator != null) {
2947                                            query = new StringBundler(2 +
2948                                                            (orderByComparator.getOrderByFields().length * 3));
2949    
2950                                            query.append(_SQL_SELECT_LAYOUT);
2951    
2952                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2953                                                    orderByComparator);
2954    
2955                                            sql = query.toString();
2956                                    }
2957                                    else {
2958                                            sql = _SQL_SELECT_LAYOUT.concat(LayoutModelImpl.ORDER_BY_JPQL);
2959                                    }
2960    
2961                                    Query q = session.createQuery(sql);
2962    
2963                                    if (orderByComparator == null) {
2964                                            list = (List<Layout>)QueryUtil.list(q, getDialect(), start,
2965                                                            end, false);
2966    
2967                                            Collections.sort(list);
2968                                    }
2969                                    else {
2970                                            list = (List<Layout>)QueryUtil.list(q, getDialect(), start,
2971                                                            end);
2972                                    }
2973                            }
2974                            catch (Exception e) {
2975                                    throw processException(e);
2976                            }
2977                            finally {
2978                                    if (list == null) {
2979                                            list = new ArrayList<Layout>();
2980                                    }
2981    
2982                                    cacheResult(list);
2983    
2984                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
2985    
2986                                    closeSession(session);
2987                            }
2988                    }
2989    
2990                    return list;
2991            }
2992    
2993            public void removeByUuid(String uuid) throws SystemException {
2994                    for (Layout layout : findByUuid(uuid)) {
2995                            remove(layout);
2996                    }
2997            }
2998    
2999            public void removeByUUID_G(String uuid, long groupId)
3000                    throws NoSuchLayoutException, SystemException {
3001                    Layout layout = findByUUID_G(uuid, groupId);
3002    
3003                    remove(layout);
3004            }
3005    
3006            public void removeByGroupId(long groupId) throws SystemException {
3007                    for (Layout layout : findByGroupId(groupId)) {
3008                            remove(layout);
3009                    }
3010            }
3011    
3012            public void removeByCompanyId(long companyId) throws SystemException {
3013                    for (Layout layout : findByCompanyId(companyId)) {
3014                            remove(layout);
3015                    }
3016            }
3017    
3018            public void removeByDLFolderId(long dlFolderId)
3019                    throws NoSuchLayoutException, SystemException {
3020                    Layout layout = findByDLFolderId(dlFolderId);
3021    
3022                    remove(layout);
3023            }
3024    
3025            public void removeByIconImageId(long iconImageId)
3026                    throws NoSuchLayoutException, SystemException {
3027                    Layout layout = findByIconImageId(iconImageId);
3028    
3029                    remove(layout);
3030            }
3031    
3032            public void removeByG_P(long groupId, boolean privateLayout)
3033                    throws SystemException {
3034                    for (Layout layout : findByG_P(groupId, privateLayout)) {
3035                            remove(layout);
3036                    }
3037            }
3038    
3039            public void removeByG_P_L(long groupId, boolean privateLayout, long layoutId)
3040                    throws NoSuchLayoutException, SystemException {
3041                    Layout layout = findByG_P_L(groupId, privateLayout, layoutId);
3042    
3043                    remove(layout);
3044            }
3045    
3046            public void removeByG_P_P(long groupId, boolean privateLayout,
3047                    long parentLayoutId) throws SystemException {
3048                    for (Layout layout : findByG_P_P(groupId, privateLayout, parentLayoutId)) {
3049                            remove(layout);
3050                    }
3051            }
3052    
3053            public void removeByG_P_F(long groupId, boolean privateLayout,
3054                    String friendlyURL) throws NoSuchLayoutException, SystemException {
3055                    Layout layout = findByG_P_F(groupId, privateLayout, friendlyURL);
3056    
3057                    remove(layout);
3058            }
3059    
3060            public void removeByG_P_T(long groupId, boolean privateLayout, String type)
3061                    throws SystemException {
3062                    for (Layout layout : findByG_P_T(groupId, privateLayout, type)) {
3063                            remove(layout);
3064                    }
3065            }
3066    
3067            public void removeAll() throws SystemException {
3068                    for (Layout layout : findAll()) {
3069                            remove(layout);
3070                    }
3071            }
3072    
3073            public int countByUuid(String uuid) throws SystemException {
3074                    Object[] finderArgs = new Object[] { uuid };
3075    
3076                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_UUID,
3077                                    finderArgs, this);
3078    
3079                    if (count == null) {
3080                            Session session = null;
3081    
3082                            try {
3083                                    session = openSession();
3084    
3085                                    StringBundler query = new StringBundler(2);
3086    
3087                                    query.append(_SQL_COUNT_LAYOUT_WHERE);
3088    
3089                                    if (uuid == null) {
3090                                            query.append(_FINDER_COLUMN_UUID_UUID_1);
3091                                    }
3092                                    else {
3093                                            if (uuid.equals(StringPool.BLANK)) {
3094                                                    query.append(_FINDER_COLUMN_UUID_UUID_3);
3095                                            }
3096                                            else {
3097                                                    query.append(_FINDER_COLUMN_UUID_UUID_2);
3098                                            }
3099                                    }
3100    
3101                                    String sql = query.toString();
3102    
3103                                    Query q = session.createQuery(sql);
3104    
3105                                    QueryPos qPos = QueryPos.getInstance(q);
3106    
3107                                    if (uuid != null) {
3108                                            qPos.add(uuid);
3109                                    }
3110    
3111                                    count = (Long)q.uniqueResult();
3112                            }
3113                            catch (Exception e) {
3114                                    throw processException(e);
3115                            }
3116                            finally {
3117                                    if (count == null) {
3118                                            count = Long.valueOf(0);
3119                                    }
3120    
3121                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID,
3122                                            finderArgs, count);
3123    
3124                                    closeSession(session);
3125                            }
3126                    }
3127    
3128                    return count.intValue();
3129            }
3130    
3131            public int countByUUID_G(String uuid, long groupId)
3132                    throws SystemException {
3133                    Object[] finderArgs = new Object[] { uuid, groupId };
3134    
3135                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_UUID_G,
3136                                    finderArgs, this);
3137    
3138                    if (count == null) {
3139                            Session session = null;
3140    
3141                            try {
3142                                    session = openSession();
3143    
3144                                    StringBundler query = new StringBundler(3);
3145    
3146                                    query.append(_SQL_COUNT_LAYOUT_WHERE);
3147    
3148                                    if (uuid == null) {
3149                                            query.append(_FINDER_COLUMN_UUID_G_UUID_1);
3150                                    }
3151                                    else {
3152                                            if (uuid.equals(StringPool.BLANK)) {
3153                                                    query.append(_FINDER_COLUMN_UUID_G_UUID_3);
3154                                            }
3155                                            else {
3156                                                    query.append(_FINDER_COLUMN_UUID_G_UUID_2);
3157                                            }
3158                                    }
3159    
3160                                    query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
3161    
3162                                    String sql = query.toString();
3163    
3164                                    Query q = session.createQuery(sql);
3165    
3166                                    QueryPos qPos = QueryPos.getInstance(q);
3167    
3168                                    if (uuid != null) {
3169                                            qPos.add(uuid);
3170                                    }
3171    
3172                                    qPos.add(groupId);
3173    
3174                                    count = (Long)q.uniqueResult();
3175                            }
3176                            catch (Exception e) {
3177                                    throw processException(e);
3178                            }
3179                            finally {
3180                                    if (count == null) {
3181                                            count = Long.valueOf(0);
3182                                    }
3183    
3184                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID_G,
3185                                            finderArgs, count);
3186    
3187                                    closeSession(session);
3188                            }
3189                    }
3190    
3191                    return count.intValue();
3192            }
3193    
3194            public int countByGroupId(long groupId) throws SystemException {
3195                    Object[] finderArgs = new Object[] { groupId };
3196    
3197                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_GROUPID,
3198                                    finderArgs, this);
3199    
3200                    if (count == null) {
3201                            Session session = null;
3202    
3203                            try {
3204                                    session = openSession();
3205    
3206                                    StringBundler query = new StringBundler(2);
3207    
3208                                    query.append(_SQL_COUNT_LAYOUT_WHERE);
3209    
3210                                    query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
3211    
3212                                    String sql = query.toString();
3213    
3214                                    Query q = session.createQuery(sql);
3215    
3216                                    QueryPos qPos = QueryPos.getInstance(q);
3217    
3218                                    qPos.add(groupId);
3219    
3220                                    count = (Long)q.uniqueResult();
3221                            }
3222                            catch (Exception e) {
3223                                    throw processException(e);
3224                            }
3225                            finally {
3226                                    if (count == null) {
3227                                            count = Long.valueOf(0);
3228                                    }
3229    
3230                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_GROUPID,
3231                                            finderArgs, count);
3232    
3233                                    closeSession(session);
3234                            }
3235                    }
3236    
3237                    return count.intValue();
3238            }
3239    
3240            public int countByCompanyId(long companyId) throws SystemException {
3241                    Object[] finderArgs = new Object[] { companyId };
3242    
3243                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_COMPANYID,
3244                                    finderArgs, this);
3245    
3246                    if (count == null) {
3247                            Session session = null;
3248    
3249                            try {
3250                                    session = openSession();
3251    
3252                                    StringBundler query = new StringBundler(2);
3253    
3254                                    query.append(_SQL_COUNT_LAYOUT_WHERE);
3255    
3256                                    query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
3257    
3258                                    String sql = query.toString();
3259    
3260                                    Query q = session.createQuery(sql);
3261    
3262                                    QueryPos qPos = QueryPos.getInstance(q);
3263    
3264                                    qPos.add(companyId);
3265    
3266                                    count = (Long)q.uniqueResult();
3267                            }
3268                            catch (Exception e) {
3269                                    throw processException(e);
3270                            }
3271                            finally {
3272                                    if (count == null) {
3273                                            count = Long.valueOf(0);
3274                                    }
3275    
3276                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_COMPANYID,
3277                                            finderArgs, count);
3278    
3279                                    closeSession(session);
3280                            }
3281                    }
3282    
3283                    return count.intValue();
3284            }
3285    
3286            public int countByDLFolderId(long dlFolderId) throws SystemException {
3287                    Object[] finderArgs = new Object[] { dlFolderId };
3288    
3289                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_DLFOLDERID,
3290                                    finderArgs, this);
3291    
3292                    if (count == null) {
3293                            Session session = null;
3294    
3295                            try {
3296                                    session = openSession();
3297    
3298                                    StringBundler query = new StringBundler(2);
3299    
3300                                    query.append(_SQL_COUNT_LAYOUT_WHERE);
3301    
3302                                    query.append(_FINDER_COLUMN_DLFOLDERID_DLFOLDERID_2);
3303    
3304                                    String sql = query.toString();
3305    
3306                                    Query q = session.createQuery(sql);
3307    
3308                                    QueryPos qPos = QueryPos.getInstance(q);
3309    
3310                                    qPos.add(dlFolderId);
3311    
3312                                    count = (Long)q.uniqueResult();
3313                            }
3314                            catch (Exception e) {
3315                                    throw processException(e);
3316                            }
3317                            finally {
3318                                    if (count == null) {
3319                                            count = Long.valueOf(0);
3320                                    }
3321    
3322                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_DLFOLDERID,
3323                                            finderArgs, count);
3324    
3325                                    closeSession(session);
3326                            }
3327                    }
3328    
3329                    return count.intValue();
3330            }
3331    
3332            public int countByIconImageId(long iconImageId) throws SystemException {
3333                    Object[] finderArgs = new Object[] { iconImageId };
3334    
3335                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_ICONIMAGEID,
3336                                    finderArgs, this);
3337    
3338                    if (count == null) {
3339                            Session session = null;
3340    
3341                            try {
3342                                    session = openSession();
3343    
3344                                    StringBundler query = new StringBundler(2);
3345    
3346                                    query.append(_SQL_COUNT_LAYOUT_WHERE);
3347    
3348                                    query.append(_FINDER_COLUMN_ICONIMAGEID_ICONIMAGEID_2);
3349    
3350                                    String sql = query.toString();
3351    
3352                                    Query q = session.createQuery(sql);
3353    
3354                                    QueryPos qPos = QueryPos.getInstance(q);
3355    
3356                                    qPos.add(iconImageId);
3357    
3358                                    count = (Long)q.uniqueResult();
3359                            }
3360                            catch (Exception e) {
3361                                    throw processException(e);
3362                            }
3363                            finally {
3364                                    if (count == null) {
3365                                            count = Long.valueOf(0);
3366                                    }
3367    
3368                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_ICONIMAGEID,
3369                                            finderArgs, count);
3370    
3371                                    closeSession(session);
3372                            }
3373                    }
3374    
3375                    return count.intValue();
3376            }
3377    
3378            public int countByG_P(long groupId, boolean privateLayout)
3379                    throws SystemException {
3380                    Object[] finderArgs = new Object[] { groupId, privateLayout };
3381    
3382                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_P,
3383                                    finderArgs, this);
3384    
3385                    if (count == null) {
3386                            Session session = null;
3387    
3388                            try {
3389                                    session = openSession();
3390    
3391                                    StringBundler query = new StringBundler(3);
3392    
3393                                    query.append(_SQL_COUNT_LAYOUT_WHERE);
3394    
3395                                    query.append(_FINDER_COLUMN_G_P_GROUPID_2);
3396    
3397                                    query.append(_FINDER_COLUMN_G_P_PRIVATELAYOUT_2);
3398    
3399                                    String sql = query.toString();
3400    
3401                                    Query q = session.createQuery(sql);
3402    
3403                                    QueryPos qPos = QueryPos.getInstance(q);
3404    
3405                                    qPos.add(groupId);
3406    
3407                                    qPos.add(privateLayout);
3408    
3409                                    count = (Long)q.uniqueResult();
3410                            }
3411                            catch (Exception e) {
3412                                    throw processException(e);
3413                            }
3414                            finally {
3415                                    if (count == null) {
3416                                            count = Long.valueOf(0);
3417                                    }
3418    
3419                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_P, finderArgs,
3420                                            count);
3421    
3422                                    closeSession(session);
3423                            }
3424                    }
3425    
3426                    return count.intValue();
3427            }
3428    
3429            public int countByG_P_L(long groupId, boolean privateLayout, long layoutId)
3430                    throws SystemException {
3431                    Object[] finderArgs = new Object[] { groupId, privateLayout, layoutId };
3432    
3433                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_P_L,
3434                                    finderArgs, this);
3435    
3436                    if (count == null) {
3437                            Session session = null;
3438    
3439                            try {
3440                                    session = openSession();
3441    
3442                                    StringBundler query = new StringBundler(4);
3443    
3444                                    query.append(_SQL_COUNT_LAYOUT_WHERE);
3445    
3446                                    query.append(_FINDER_COLUMN_G_P_L_GROUPID_2);
3447    
3448                                    query.append(_FINDER_COLUMN_G_P_L_PRIVATELAYOUT_2);
3449    
3450                                    query.append(_FINDER_COLUMN_G_P_L_LAYOUTID_2);
3451    
3452                                    String sql = query.toString();
3453    
3454                                    Query q = session.createQuery(sql);
3455    
3456                                    QueryPos qPos = QueryPos.getInstance(q);
3457    
3458                                    qPos.add(groupId);
3459    
3460                                    qPos.add(privateLayout);
3461    
3462                                    qPos.add(layoutId);
3463    
3464                                    count = (Long)q.uniqueResult();
3465                            }
3466                            catch (Exception e) {
3467                                    throw processException(e);
3468                            }
3469                            finally {
3470                                    if (count == null) {
3471                                            count = Long.valueOf(0);
3472                                    }
3473    
3474                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_P_L,
3475                                            finderArgs, count);
3476    
3477                                    closeSession(session);
3478                            }
3479                    }
3480    
3481                    return count.intValue();
3482            }
3483    
3484            public int countByG_P_P(long groupId, boolean privateLayout,
3485                    long parentLayoutId) throws SystemException {
3486                    Object[] finderArgs = new Object[] {
3487                                    groupId, privateLayout, parentLayoutId
3488                            };
3489    
3490                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_P_P,
3491                                    finderArgs, this);
3492    
3493                    if (count == null) {
3494                            Session session = null;
3495    
3496                            try {
3497                                    session = openSession();
3498    
3499                                    StringBundler query = new StringBundler(4);
3500    
3501                                    query.append(_SQL_COUNT_LAYOUT_WHERE);
3502    
3503                                    query.append(_FINDER_COLUMN_G_P_P_GROUPID_2);
3504    
3505                                    query.append(_FINDER_COLUMN_G_P_P_PRIVATELAYOUT_2);
3506    
3507                                    query.append(_FINDER_COLUMN_G_P_P_PARENTLAYOUTID_2);
3508    
3509                                    String sql = query.toString();
3510    
3511                                    Query q = session.createQuery(sql);
3512    
3513                                    QueryPos qPos = QueryPos.getInstance(q);
3514    
3515                                    qPos.add(groupId);
3516    
3517                                    qPos.add(privateLayout);
3518    
3519                                    qPos.add(parentLayoutId);
3520    
3521                                    count = (Long)q.uniqueResult();
3522                            }
3523                            catch (Exception e) {
3524                                    throw processException(e);
3525                            }
3526                            finally {
3527                                    if (count == null) {
3528                                            count = Long.valueOf(0);
3529                                    }
3530    
3531                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_P_P,
3532                                            finderArgs, count);
3533    
3534                                    closeSession(session);
3535                            }
3536                    }
3537    
3538                    return count.intValue();
3539            }
3540    
3541            public int countByG_P_F(long groupId, boolean privateLayout,
3542                    String friendlyURL) throws SystemException {
3543                    Object[] finderArgs = new Object[] { groupId, privateLayout, friendlyURL };
3544    
3545                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_P_F,
3546                                    finderArgs, this);
3547    
3548                    if (count == null) {
3549                            Session session = null;
3550    
3551                            try {
3552                                    session = openSession();
3553    
3554                                    StringBundler query = new StringBundler(4);
3555    
3556                                    query.append(_SQL_COUNT_LAYOUT_WHERE);
3557    
3558                                    query.append(_FINDER_COLUMN_G_P_F_GROUPID_2);
3559    
3560                                    query.append(_FINDER_COLUMN_G_P_F_PRIVATELAYOUT_2);
3561    
3562                                    if (friendlyURL == null) {
3563                                            query.append(_FINDER_COLUMN_G_P_F_FRIENDLYURL_1);
3564                                    }
3565                                    else {
3566                                            if (friendlyURL.equals(StringPool.BLANK)) {
3567                                                    query.append(_FINDER_COLUMN_G_P_F_FRIENDLYURL_3);
3568                                            }
3569                                            else {
3570                                                    query.append(_FINDER_COLUMN_G_P_F_FRIENDLYURL_2);
3571                                            }
3572                                    }
3573    
3574                                    String sql = query.toString();
3575    
3576                                    Query q = session.createQuery(sql);
3577    
3578                                    QueryPos qPos = QueryPos.getInstance(q);
3579    
3580                                    qPos.add(groupId);
3581    
3582                                    qPos.add(privateLayout);
3583    
3584                                    if (friendlyURL != null) {
3585                                            qPos.add(friendlyURL);
3586                                    }
3587    
3588                                    count = (Long)q.uniqueResult();
3589                            }
3590                            catch (Exception e) {
3591                                    throw processException(e);
3592                            }
3593                            finally {
3594                                    if (count == null) {
3595                                            count = Long.valueOf(0);
3596                                    }
3597    
3598                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_P_F,
3599                                            finderArgs, count);
3600    
3601                                    closeSession(session);
3602                            }
3603                    }
3604    
3605                    return count.intValue();
3606            }
3607    
3608            public int countByG_P_T(long groupId, boolean privateLayout, String type)
3609                    throws SystemException {
3610                    Object[] finderArgs = new Object[] { groupId, privateLayout, type };
3611    
3612                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_P_T,
3613                                    finderArgs, this);
3614    
3615                    if (count == null) {
3616                            Session session = null;
3617    
3618                            try {
3619                                    session = openSession();
3620    
3621                                    StringBundler query = new StringBundler(4);
3622    
3623                                    query.append(_SQL_COUNT_LAYOUT_WHERE);
3624    
3625                                    query.append(_FINDER_COLUMN_G_P_T_GROUPID_2);
3626    
3627                                    query.append(_FINDER_COLUMN_G_P_T_PRIVATELAYOUT_2);
3628    
3629                                    if (type == null) {
3630                                            query.append(_FINDER_COLUMN_G_P_T_TYPE_1);
3631                                    }
3632                                    else {
3633                                            if (type.equals(StringPool.BLANK)) {
3634                                                    query.append(_FINDER_COLUMN_G_P_T_TYPE_3);
3635                                            }
3636                                            else {
3637                                                    query.append(_FINDER_COLUMN_G_P_T_TYPE_2);
3638                                            }
3639                                    }
3640    
3641                                    String sql = query.toString();
3642    
3643                                    Query q = session.createQuery(sql);
3644    
3645                                    QueryPos qPos = QueryPos.getInstance(q);
3646    
3647                                    qPos.add(groupId);
3648    
3649                                    qPos.add(privateLayout);
3650    
3651                                    if (type != null) {
3652                                            qPos.add(type);
3653                                    }
3654    
3655                                    count = (Long)q.uniqueResult();
3656                            }
3657                            catch (Exception e) {
3658                                    throw processException(e);
3659                            }
3660                            finally {
3661                                    if (count == null) {
3662                                            count = Long.valueOf(0);
3663                                    }
3664    
3665                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_P_T,
3666                                            finderArgs, count);
3667    
3668                                    closeSession(session);
3669                            }
3670                    }
3671    
3672                    return count.intValue();
3673            }
3674    
3675            public int countAll() throws SystemException {
3676                    Object[] finderArgs = new Object[0];
3677    
3678                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
3679                                    finderArgs, this);
3680    
3681                    if (count == null) {
3682                            Session session = null;
3683    
3684                            try {
3685                                    session = openSession();
3686    
3687                                    Query q = session.createQuery(_SQL_COUNT_LAYOUT);
3688    
3689                                    count = (Long)q.uniqueResult();
3690                            }
3691                            catch (Exception e) {
3692                                    throw processException(e);
3693                            }
3694                            finally {
3695                                    if (count == null) {
3696                                            count = Long.valueOf(0);
3697                                    }
3698    
3699                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
3700                                            count);
3701    
3702                                    closeSession(session);
3703                            }
3704                    }
3705    
3706                    return count.intValue();
3707            }
3708    
3709            public void afterPropertiesSet() {
3710                    String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
3711                                            com.liferay.portal.util.PropsUtil.get(
3712                                                    "value.object.listener.com.liferay.portal.model.Layout")));
3713    
3714                    if (listenerClassNames.length > 0) {
3715                            try {
3716                                    List<ModelListener<Layout>> listenersList = new ArrayList<ModelListener<Layout>>();
3717    
3718                                    for (String listenerClassName : listenerClassNames) {
3719                                            listenersList.add((ModelListener<Layout>)InstanceFactory.newInstance(
3720                                                            listenerClassName));
3721                                    }
3722    
3723                                    listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
3724                            }
3725                            catch (Exception e) {
3726                                    _log.error(e);
3727                            }
3728                    }
3729            }
3730    
3731            @BeanReference(type = AccountPersistence.class)
3732            protected AccountPersistence accountPersistence;
3733            @BeanReference(type = AddressPersistence.class)
3734            protected AddressPersistence addressPersistence;
3735            @BeanReference(type = BrowserTrackerPersistence.class)
3736            protected BrowserTrackerPersistence browserTrackerPersistence;
3737            @BeanReference(type = ClassNamePersistence.class)
3738            protected ClassNamePersistence classNamePersistence;
3739            @BeanReference(type = CompanyPersistence.class)
3740            protected CompanyPersistence companyPersistence;
3741            @BeanReference(type = ContactPersistence.class)
3742            protected ContactPersistence contactPersistence;
3743            @BeanReference(type = CountryPersistence.class)
3744            protected CountryPersistence countryPersistence;
3745            @BeanReference(type = EmailAddressPersistence.class)
3746            protected EmailAddressPersistence emailAddressPersistence;
3747            @BeanReference(type = GroupPersistence.class)
3748            protected GroupPersistence groupPersistence;
3749            @BeanReference(type = ImagePersistence.class)
3750            protected ImagePersistence imagePersistence;
3751            @BeanReference(type = LayoutPersistence.class)
3752            protected LayoutPersistence layoutPersistence;
3753            @BeanReference(type = LayoutPrototypePersistence.class)
3754            protected LayoutPrototypePersistence layoutPrototypePersistence;
3755            @BeanReference(type = LayoutSetPersistence.class)
3756            protected LayoutSetPersistence layoutSetPersistence;
3757            @BeanReference(type = LayoutSetPrototypePersistence.class)
3758            protected LayoutSetPrototypePersistence layoutSetPrototypePersistence;
3759            @BeanReference(type = ListTypePersistence.class)
3760            protected ListTypePersistence listTypePersistence;
3761            @BeanReference(type = LockPersistence.class)
3762            protected LockPersistence lockPersistence;
3763            @BeanReference(type = MembershipRequestPersistence.class)
3764            protected MembershipRequestPersistence membershipRequestPersistence;
3765            @BeanReference(type = OrganizationPersistence.class)
3766            protected OrganizationPersistence organizationPersistence;
3767            @BeanReference(type = OrgGroupPermissionPersistence.class)
3768            protected OrgGroupPermissionPersistence orgGroupPermissionPersistence;
3769            @BeanReference(type = OrgGroupRolePersistence.class)
3770            protected OrgGroupRolePersistence orgGroupRolePersistence;
3771            @BeanReference(type = OrgLaborPersistence.class)
3772            protected OrgLaborPersistence orgLaborPersistence;
3773            @BeanReference(type = PasswordPolicyPersistence.class)
3774            protected PasswordPolicyPersistence passwordPolicyPersistence;
3775            @BeanReference(type = PasswordPolicyRelPersistence.class)
3776            protected PasswordPolicyRelPersistence passwordPolicyRelPersistence;
3777            @BeanReference(type = PasswordTrackerPersistence.class)
3778            protected PasswordTrackerPersistence passwordTrackerPersistence;
3779            @BeanReference(type = PermissionPersistence.class)
3780            protected PermissionPersistence permissionPersistence;
3781            @BeanReference(type = PhonePersistence.class)
3782            protected PhonePersistence phonePersistence;
3783            @BeanReference(type = PluginSettingPersistence.class)
3784            protected PluginSettingPersistence pluginSettingPersistence;
3785            @BeanReference(type = PortletPersistence.class)
3786            protected PortletPersistence portletPersistence;
3787            @BeanReference(type = PortletItemPersistence.class)
3788            protected PortletItemPersistence portletItemPersistence;
3789            @BeanReference(type = PortletPreferencesPersistence.class)
3790            protected PortletPreferencesPersistence portletPreferencesPersistence;
3791            @BeanReference(type = RegionPersistence.class)
3792            protected RegionPersistence regionPersistence;
3793            @BeanReference(type = ReleasePersistence.class)
3794            protected ReleasePersistence releasePersistence;
3795            @BeanReference(type = ResourcePersistence.class)
3796            protected ResourcePersistence resourcePersistence;
3797            @BeanReference(type = ResourceActionPersistence.class)
3798            protected ResourceActionPersistence resourceActionPersistence;
3799            @BeanReference(type = ResourceCodePersistence.class)
3800            protected ResourceCodePersistence resourceCodePersistence;
3801            @BeanReference(type = ResourcePermissionPersistence.class)
3802            protected ResourcePermissionPersistence resourcePermissionPersistence;
3803            @BeanReference(type = RolePersistence.class)
3804            protected RolePersistence rolePersistence;
3805            @BeanReference(type = ServiceComponentPersistence.class)
3806            protected ServiceComponentPersistence serviceComponentPersistence;
3807            @BeanReference(type = ShardPersistence.class)
3808            protected ShardPersistence shardPersistence;
3809            @BeanReference(type = SubscriptionPersistence.class)
3810            protected SubscriptionPersistence subscriptionPersistence;
3811            @BeanReference(type = TicketPersistence.class)
3812            protected TicketPersistence ticketPersistence;
3813            @BeanReference(type = TeamPersistence.class)
3814            protected TeamPersistence teamPersistence;
3815            @BeanReference(type = UserPersistence.class)
3816            protected UserPersistence userPersistence;
3817            @BeanReference(type = UserGroupPersistence.class)
3818            protected UserGroupPersistence userGroupPersistence;
3819            @BeanReference(type = UserGroupGroupRolePersistence.class)
3820            protected UserGroupGroupRolePersistence userGroupGroupRolePersistence;
3821            @BeanReference(type = UserGroupRolePersistence.class)
3822            protected UserGroupRolePersistence userGroupRolePersistence;
3823            @BeanReference(type = UserIdMapperPersistence.class)
3824            protected UserIdMapperPersistence userIdMapperPersistence;
3825            @BeanReference(type = UserTrackerPersistence.class)
3826            protected UserTrackerPersistence userTrackerPersistence;
3827            @BeanReference(type = UserTrackerPathPersistence.class)
3828            protected UserTrackerPathPersistence userTrackerPathPersistence;
3829            @BeanReference(type = WebDAVPropsPersistence.class)
3830            protected WebDAVPropsPersistence webDAVPropsPersistence;
3831            @BeanReference(type = WebsitePersistence.class)
3832            protected WebsitePersistence websitePersistence;
3833            @BeanReference(type = WorkflowDefinitionLinkPersistence.class)
3834            protected WorkflowDefinitionLinkPersistence workflowDefinitionLinkPersistence;
3835            @BeanReference(type = WorkflowInstanceLinkPersistence.class)
3836            protected WorkflowInstanceLinkPersistence workflowInstanceLinkPersistence;
3837            @BeanReference(type = DLFolderPersistence.class)
3838            protected DLFolderPersistence dlFolderPersistence;
3839            @BeanReference(type = ExpandoValuePersistence.class)
3840            protected ExpandoValuePersistence expandoValuePersistence;
3841            @BeanReference(type = JournalContentSearchPersistence.class)
3842            protected JournalContentSearchPersistence journalContentSearchPersistence;
3843            @BeanReference(type = MBMessagePersistence.class)
3844            protected MBMessagePersistence mbMessagePersistence;
3845            @BeanReference(type = RatingsStatsPersistence.class)
3846            protected RatingsStatsPersistence ratingsStatsPersistence;
3847            @BeanReference(type = TasksProposalPersistence.class)
3848            protected TasksProposalPersistence tasksProposalPersistence;
3849            private static final String _SQL_SELECT_LAYOUT = "SELECT layout FROM Layout layout";
3850            private static final String _SQL_SELECT_LAYOUT_WHERE = "SELECT layout FROM Layout layout WHERE ";
3851            private static final String _SQL_COUNT_LAYOUT = "SELECT COUNT(layout) FROM Layout layout";
3852            private static final String _SQL_COUNT_LAYOUT_WHERE = "SELECT COUNT(layout) FROM Layout layout WHERE ";
3853            private static final String _FINDER_COLUMN_UUID_UUID_1 = "layout.uuid IS NULL";
3854            private static final String _FINDER_COLUMN_UUID_UUID_2 = "layout.uuid = ?";
3855            private static final String _FINDER_COLUMN_UUID_UUID_3 = "(layout.uuid IS NULL OR layout.uuid = ?)";
3856            private static final String _FINDER_COLUMN_UUID_G_UUID_1 = "layout.uuid IS NULL AND ";
3857            private static final String _FINDER_COLUMN_UUID_G_UUID_2 = "layout.uuid = ? AND ";
3858            private static final String _FINDER_COLUMN_UUID_G_UUID_3 = "(layout.uuid IS NULL OR layout.uuid = ?) AND ";
3859            private static final String _FINDER_COLUMN_UUID_G_GROUPID_2 = "layout.groupId = ?";
3860            private static final String _FINDER_COLUMN_GROUPID_GROUPID_2 = "layout.groupId = ?";
3861            private static final String _FINDER_COLUMN_COMPANYID_COMPANYID_2 = "layout.companyId = ?";
3862            private static final String _FINDER_COLUMN_DLFOLDERID_DLFOLDERID_2 = "layout.dlFolderId = ?";
3863            private static final String _FINDER_COLUMN_ICONIMAGEID_ICONIMAGEID_2 = "layout.iconImageId = ?";
3864            private static final String _FINDER_COLUMN_G_P_GROUPID_2 = "layout.groupId = ? AND ";
3865            private static final String _FINDER_COLUMN_G_P_PRIVATELAYOUT_2 = "layout.privateLayout = ?";
3866            private static final String _FINDER_COLUMN_G_P_L_GROUPID_2 = "layout.groupId = ? AND ";
3867            private static final String _FINDER_COLUMN_G_P_L_PRIVATELAYOUT_2 = "layout.privateLayout = ? AND ";
3868            private static final String _FINDER_COLUMN_G_P_L_LAYOUTID_2 = "layout.layoutId = ?";
3869            private static final String _FINDER_COLUMN_G_P_P_GROUPID_2 = "layout.groupId = ? AND ";
3870            private static final String _FINDER_COLUMN_G_P_P_PRIVATELAYOUT_2 = "layout.privateLayout = ? AND ";
3871            private static final String _FINDER_COLUMN_G_P_P_PARENTLAYOUTID_2 = "layout.parentLayoutId = ?";
3872            private static final String _FINDER_COLUMN_G_P_F_GROUPID_2 = "layout.groupId = ? AND ";
3873            private static final String _FINDER_COLUMN_G_P_F_PRIVATELAYOUT_2 = "layout.privateLayout = ? AND ";
3874            private static final String _FINDER_COLUMN_G_P_F_FRIENDLYURL_1 = "layout.friendlyURL IS NULL";
3875            private static final String _FINDER_COLUMN_G_P_F_FRIENDLYURL_2 = "layout.friendlyURL = ?";
3876            private static final String _FINDER_COLUMN_G_P_F_FRIENDLYURL_3 = "(layout.friendlyURL IS NULL OR layout.friendlyURL = ?)";
3877            private static final String _FINDER_COLUMN_G_P_T_GROUPID_2 = "layout.groupId = ? AND ";
3878            private static final String _FINDER_COLUMN_G_P_T_PRIVATELAYOUT_2 = "layout.privateLayout = ? AND ";
3879            private static final String _FINDER_COLUMN_G_P_T_TYPE_1 = "layout.type IS NULL";
3880            private static final String _FINDER_COLUMN_G_P_T_TYPE_2 = "layout.type = ?";
3881            private static final String _FINDER_COLUMN_G_P_T_TYPE_3 = "(layout.type IS NULL OR layout.type = ?)";
3882            private static final String _ORDER_BY_ENTITY_ALIAS = "layout.";
3883            private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No Layout exists with the primary key ";
3884            private static final String _NO_SUCH_ENTITY_WITH_KEY = "No Layout exists with the key {";
3885            private static Log _log = LogFactoryUtil.getLog(LayoutPersistenceImpl.class);
3886    }