001    /**
002     * Copyright (c) 2000-2012 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.portlet.journal.service.persistence;
016    
017    import com.liferay.portal.NoSuchModelException;
018    import com.liferay.portal.kernel.bean.BeanReference;
019    import com.liferay.portal.kernel.cache.CacheRegistryUtil;
020    import com.liferay.portal.kernel.dao.orm.EntityCacheUtil;
021    import com.liferay.portal.kernel.dao.orm.FinderCacheUtil;
022    import com.liferay.portal.kernel.dao.orm.FinderPath;
023    import com.liferay.portal.kernel.dao.orm.Query;
024    import com.liferay.portal.kernel.dao.orm.QueryPos;
025    import com.liferay.portal.kernel.dao.orm.QueryUtil;
026    import com.liferay.portal.kernel.dao.orm.Session;
027    import com.liferay.portal.kernel.exception.SystemException;
028    import com.liferay.portal.kernel.log.Log;
029    import com.liferay.portal.kernel.log.LogFactoryUtil;
030    import com.liferay.portal.kernel.util.GetterUtil;
031    import com.liferay.portal.kernel.util.InstanceFactory;
032    import com.liferay.portal.kernel.util.OrderByComparator;
033    import com.liferay.portal.kernel.util.StringBundler;
034    import com.liferay.portal.kernel.util.StringPool;
035    import com.liferay.portal.kernel.util.StringUtil;
036    import com.liferay.portal.kernel.util.Validator;
037    import com.liferay.portal.kernel.uuid.PortalUUIDUtil;
038    import com.liferay.portal.model.CacheModel;
039    import com.liferay.portal.model.ModelListener;
040    import com.liferay.portal.service.persistence.UserPersistence;
041    import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
042    
043    import com.liferay.portlet.journal.NoSuchArticleResourceException;
044    import com.liferay.portlet.journal.model.JournalArticleResource;
045    import com.liferay.portlet.journal.model.impl.JournalArticleResourceImpl;
046    import com.liferay.portlet.journal.model.impl.JournalArticleResourceModelImpl;
047    
048    import java.io.Serializable;
049    
050    import java.util.ArrayList;
051    import java.util.Collections;
052    import java.util.List;
053    
054    /**
055     * The persistence implementation for the journal article resource service.
056     *
057     * <p>
058     * Caching information and settings can be found in <code>portal.properties</code>
059     * </p>
060     *
061     * @author Brian Wing Shun Chan
062     * @see JournalArticleResourcePersistence
063     * @see JournalArticleResourceUtil
064     * @generated
065     */
066    public class JournalArticleResourcePersistenceImpl extends BasePersistenceImpl<JournalArticleResource>
067            implements JournalArticleResourcePersistence {
068            /*
069             * NOTE FOR DEVELOPERS:
070             *
071             * Never modify or reference this class directly. Always use {@link JournalArticleResourceUtil} to access the journal article resource persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
072             */
073            public static final String FINDER_CLASS_NAME_ENTITY = JournalArticleResourceImpl.class.getName();
074            public static final String FINDER_CLASS_NAME_LIST_WITH_PAGINATION = FINDER_CLASS_NAME_ENTITY +
075                    ".List1";
076            public static final String FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION = FINDER_CLASS_NAME_ENTITY +
077                    ".List2";
078            public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_UUID = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
079                            JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
080                            JournalArticleResourceImpl.class,
081                            FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByUuid",
082                            new String[] {
083                                    String.class.getName(),
084                                    
085                            "java.lang.Integer", "java.lang.Integer",
086                                    "com.liferay.portal.kernel.util.OrderByComparator"
087                            });
088            public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
089                            JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
090                            JournalArticleResourceImpl.class,
091                            FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByUuid",
092                            new String[] { String.class.getName() },
093                            JournalArticleResourceModelImpl.UUID_COLUMN_BITMASK);
094            public static final FinderPath FINDER_PATH_COUNT_BY_UUID = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
095                            JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED, Long.class,
096                            FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByUuid",
097                            new String[] { String.class.getName() });
098            public static final FinderPath FINDER_PATH_FETCH_BY_UUID_G = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
099                            JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
100                            JournalArticleResourceImpl.class, FINDER_CLASS_NAME_ENTITY,
101                            "fetchByUUID_G",
102                            new String[] { String.class.getName(), Long.class.getName() },
103                            JournalArticleResourceModelImpl.UUID_COLUMN_BITMASK |
104                            JournalArticleResourceModelImpl.GROUPID_COLUMN_BITMASK);
105            public static final FinderPath FINDER_PATH_COUNT_BY_UUID_G = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
106                            JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED, Long.class,
107                            FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByUUID_G",
108                            new String[] { String.class.getName(), Long.class.getName() });
109            public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_BY_GROUPID = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
110                            JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
111                            JournalArticleResourceImpl.class,
112                            FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findByGroupId",
113                            new String[] {
114                                    Long.class.getName(),
115                                    
116                            "java.lang.Integer", "java.lang.Integer",
117                                    "com.liferay.portal.kernel.util.OrderByComparator"
118                            });
119            public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID =
120                    new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
121                            JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
122                            JournalArticleResourceImpl.class,
123                            FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findByGroupId",
124                            new String[] { Long.class.getName() },
125                            JournalArticleResourceModelImpl.GROUPID_COLUMN_BITMASK);
126            public static final FinderPath FINDER_PATH_COUNT_BY_GROUPID = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
127                            JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED, Long.class,
128                            FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByGroupId",
129                            new String[] { Long.class.getName() });
130            public static final FinderPath FINDER_PATH_FETCH_BY_G_A = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
131                            JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
132                            JournalArticleResourceImpl.class, FINDER_CLASS_NAME_ENTITY,
133                            "fetchByG_A",
134                            new String[] { Long.class.getName(), String.class.getName() },
135                            JournalArticleResourceModelImpl.GROUPID_COLUMN_BITMASK |
136                            JournalArticleResourceModelImpl.ARTICLEID_COLUMN_BITMASK);
137            public static final FinderPath FINDER_PATH_COUNT_BY_G_A = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
138                            JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED, Long.class,
139                            FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countByG_A",
140                            new String[] { Long.class.getName(), String.class.getName() });
141            public static final FinderPath FINDER_PATH_WITH_PAGINATION_FIND_ALL = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
142                            JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
143                            JournalArticleResourceImpl.class,
144                            FINDER_CLASS_NAME_LIST_WITH_PAGINATION, "findAll", new String[0]);
145            public static final FinderPath FINDER_PATH_WITHOUT_PAGINATION_FIND_ALL = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
146                            JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
147                            JournalArticleResourceImpl.class,
148                            FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "findAll", new String[0]);
149            public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
150                            JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED, Long.class,
151                            FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION, "countAll", new String[0]);
152    
153            /**
154             * Caches the journal article resource in the entity cache if it is enabled.
155             *
156             * @param journalArticleResource the journal article resource
157             */
158            public void cacheResult(JournalArticleResource journalArticleResource) {
159                    EntityCacheUtil.putResult(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
160                            JournalArticleResourceImpl.class,
161                            journalArticleResource.getPrimaryKey(), journalArticleResource);
162    
163                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
164                            new Object[] {
165                                    journalArticleResource.getUuid(),
166                                    Long.valueOf(journalArticleResource.getGroupId())
167                            }, journalArticleResource);
168    
169                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A,
170                            new Object[] {
171                                    Long.valueOf(journalArticleResource.getGroupId()),
172                                    
173                            journalArticleResource.getArticleId()
174                            }, journalArticleResource);
175    
176                    journalArticleResource.resetOriginalValues();
177            }
178    
179            /**
180             * Caches the journal article resources in the entity cache if it is enabled.
181             *
182             * @param journalArticleResources the journal article resources
183             */
184            public void cacheResult(
185                    List<JournalArticleResource> journalArticleResources) {
186                    for (JournalArticleResource journalArticleResource : journalArticleResources) {
187                            if (EntityCacheUtil.getResult(
188                                                    JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
189                                                    JournalArticleResourceImpl.class,
190                                                    journalArticleResource.getPrimaryKey()) == null) {
191                                    cacheResult(journalArticleResource);
192                            }
193                            else {
194                                    journalArticleResource.resetOriginalValues();
195                            }
196                    }
197            }
198    
199            /**
200             * Clears the cache for all journal article resources.
201             *
202             * <p>
203             * The {@link com.liferay.portal.kernel.dao.orm.EntityCache} and {@link com.liferay.portal.kernel.dao.orm.FinderCache} are both cleared by this method.
204             * </p>
205             */
206            @Override
207            public void clearCache() {
208                    if (_HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE) {
209                            CacheRegistryUtil.clear(JournalArticleResourceImpl.class.getName());
210                    }
211    
212                    EntityCacheUtil.clearCache(JournalArticleResourceImpl.class.getName());
213    
214                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
215                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
216                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
217            }
218    
219            /**
220             * Clears the cache for the journal article resource.
221             *
222             * <p>
223             * The {@link com.liferay.portal.kernel.dao.orm.EntityCache} and {@link com.liferay.portal.kernel.dao.orm.FinderCache} are both cleared by this method.
224             * </p>
225             */
226            @Override
227            public void clearCache(JournalArticleResource journalArticleResource) {
228                    EntityCacheUtil.removeResult(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
229                            JournalArticleResourceImpl.class,
230                            journalArticleResource.getPrimaryKey());
231    
232                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
233                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
234    
235                    clearUniqueFindersCache(journalArticleResource);
236            }
237    
238            @Override
239            public void clearCache(List<JournalArticleResource> journalArticleResources) {
240                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
241                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
242    
243                    for (JournalArticleResource journalArticleResource : journalArticleResources) {
244                            EntityCacheUtil.removeResult(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
245                                    JournalArticleResourceImpl.class,
246                                    journalArticleResource.getPrimaryKey());
247    
248                            clearUniqueFindersCache(journalArticleResource);
249                    }
250            }
251    
252            protected void clearUniqueFindersCache(
253                    JournalArticleResource journalArticleResource) {
254                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
255                            new Object[] {
256                                    journalArticleResource.getUuid(),
257                                    Long.valueOf(journalArticleResource.getGroupId())
258                            });
259    
260                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_A,
261                            new Object[] {
262                                    Long.valueOf(journalArticleResource.getGroupId()),
263                                    
264                            journalArticleResource.getArticleId()
265                            });
266            }
267    
268            /**
269             * Creates a new journal article resource with the primary key. Does not add the journal article resource to the database.
270             *
271             * @param resourcePrimKey the primary key for the new journal article resource
272             * @return the new journal article resource
273             */
274            public JournalArticleResource create(long resourcePrimKey) {
275                    JournalArticleResource journalArticleResource = new JournalArticleResourceImpl();
276    
277                    journalArticleResource.setNew(true);
278                    journalArticleResource.setPrimaryKey(resourcePrimKey);
279    
280                    String uuid = PortalUUIDUtil.generate();
281    
282                    journalArticleResource.setUuid(uuid);
283    
284                    return journalArticleResource;
285            }
286    
287            /**
288             * Removes the journal article resource with the primary key from the database. Also notifies the appropriate model listeners.
289             *
290             * @param resourcePrimKey the primary key of the journal article resource
291             * @return the journal article resource that was removed
292             * @throws com.liferay.portlet.journal.NoSuchArticleResourceException if a journal article resource with the primary key could not be found
293             * @throws SystemException if a system exception occurred
294             */
295            public JournalArticleResource remove(long resourcePrimKey)
296                    throws NoSuchArticleResourceException, SystemException {
297                    return remove(Long.valueOf(resourcePrimKey));
298            }
299    
300            /**
301             * Removes the journal article resource with the primary key from the database. Also notifies the appropriate model listeners.
302             *
303             * @param primaryKey the primary key of the journal article resource
304             * @return the journal article resource that was removed
305             * @throws com.liferay.portlet.journal.NoSuchArticleResourceException if a journal article resource with the primary key could not be found
306             * @throws SystemException if a system exception occurred
307             */
308            @Override
309            public JournalArticleResource remove(Serializable primaryKey)
310                    throws NoSuchArticleResourceException, SystemException {
311                    Session session = null;
312    
313                    try {
314                            session = openSession();
315    
316                            JournalArticleResource journalArticleResource = (JournalArticleResource)session.get(JournalArticleResourceImpl.class,
317                                            primaryKey);
318    
319                            if (journalArticleResource == null) {
320                                    if (_log.isWarnEnabled()) {
321                                            _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + primaryKey);
322                                    }
323    
324                                    throw new NoSuchArticleResourceException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
325                                            primaryKey);
326                            }
327    
328                            return remove(journalArticleResource);
329                    }
330                    catch (NoSuchArticleResourceException nsee) {
331                            throw nsee;
332                    }
333                    catch (Exception e) {
334                            throw processException(e);
335                    }
336                    finally {
337                            closeSession(session);
338                    }
339            }
340    
341            @Override
342            protected JournalArticleResource removeImpl(
343                    JournalArticleResource journalArticleResource)
344                    throws SystemException {
345                    journalArticleResource = toUnwrappedModel(journalArticleResource);
346    
347                    Session session = null;
348    
349                    try {
350                            session = openSession();
351    
352                            if (journalArticleResource.isCachedModel()) {
353                                    journalArticleResource = (JournalArticleResource)session.get(JournalArticleResourceImpl.class,
354                                                    journalArticleResource.getPrimaryKeyObj());
355                            }
356    
357                            session.delete(journalArticleResource);
358                    }
359                    catch (Exception e) {
360                            throw processException(e);
361                    }
362                    finally {
363                            closeSession(session);
364                    }
365    
366                    clearCache(journalArticleResource);
367    
368                    return journalArticleResource;
369            }
370    
371            @Override
372            public JournalArticleResource updateImpl(
373                    com.liferay.portlet.journal.model.JournalArticleResource journalArticleResource)
374                    throws SystemException {
375                    journalArticleResource = toUnwrappedModel(journalArticleResource);
376    
377                    boolean isNew = journalArticleResource.isNew();
378    
379                    JournalArticleResourceModelImpl journalArticleResourceModelImpl = (JournalArticleResourceModelImpl)journalArticleResource;
380    
381                    if (Validator.isNull(journalArticleResource.getUuid())) {
382                            String uuid = PortalUUIDUtil.generate();
383    
384                            journalArticleResource.setUuid(uuid);
385                    }
386    
387                    Session session = null;
388    
389                    try {
390                            session = openSession();
391    
392                            if (journalArticleResource.isNew()) {
393                                    session.save(journalArticleResource);
394    
395                                    journalArticleResource.setNew(false);
396                            }
397                            else {
398                                    session.merge(journalArticleResource);
399                            }
400                    }
401                    catch (Exception e) {
402                            throw processException(e);
403                    }
404                    finally {
405                            closeSession(session);
406                    }
407    
408                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITH_PAGINATION);
409    
410                    if (isNew || !JournalArticleResourceModelImpl.COLUMN_BITMASK_ENABLED) {
411                            FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
412                    }
413    
414                    else {
415                            if ((journalArticleResourceModelImpl.getColumnBitmask() &
416                                            FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID.getColumnBitmask()) != 0) {
417                                    Object[] args = new Object[] {
418                                                    journalArticleResourceModelImpl.getOriginalUuid()
419                                            };
420    
421                                    FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID, args);
422                                    FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID,
423                                            args);
424    
425                                    args = new Object[] { journalArticleResourceModelImpl.getUuid() };
426    
427                                    FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID, args);
428                                    FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID,
429                                            args);
430                            }
431    
432                            if ((journalArticleResourceModelImpl.getColumnBitmask() &
433                                            FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID.getColumnBitmask()) != 0) {
434                                    Object[] args = new Object[] {
435                                                    Long.valueOf(journalArticleResourceModelImpl.getOriginalGroupId())
436                                            };
437    
438                                    FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_GROUPID, args);
439                                    FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID,
440                                            args);
441    
442                                    args = new Object[] {
443                                                    Long.valueOf(journalArticleResourceModelImpl.getGroupId())
444                                            };
445    
446                                    FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_GROUPID, args);
447                                    FinderCacheUtil.removeResult(FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID,
448                                            args);
449                            }
450                    }
451    
452                    EntityCacheUtil.putResult(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
453                            JournalArticleResourceImpl.class,
454                            journalArticleResource.getPrimaryKey(), journalArticleResource);
455    
456                    if (isNew) {
457                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
458                                    new Object[] {
459                                            journalArticleResource.getUuid(),
460                                            Long.valueOf(journalArticleResource.getGroupId())
461                                    }, journalArticleResource);
462    
463                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A,
464                                    new Object[] {
465                                            Long.valueOf(journalArticleResource.getGroupId()),
466                                            
467                                    journalArticleResource.getArticleId()
468                                    }, journalArticleResource);
469                    }
470                    else {
471                            if ((journalArticleResourceModelImpl.getColumnBitmask() &
472                                            FINDER_PATH_FETCH_BY_UUID_G.getColumnBitmask()) != 0) {
473                                    Object[] args = new Object[] {
474                                                    journalArticleResourceModelImpl.getOriginalUuid(),
475                                                    Long.valueOf(journalArticleResourceModelImpl.getOriginalGroupId())
476                                            };
477    
478                                    FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_UUID_G, args);
479    
480                                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G, args);
481    
482                                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
483                                            new Object[] {
484                                                    journalArticleResource.getUuid(),
485                                                    Long.valueOf(journalArticleResource.getGroupId())
486                                            }, journalArticleResource);
487                            }
488    
489                            if ((journalArticleResourceModelImpl.getColumnBitmask() &
490                                            FINDER_PATH_FETCH_BY_G_A.getColumnBitmask()) != 0) {
491                                    Object[] args = new Object[] {
492                                                    Long.valueOf(journalArticleResourceModelImpl.getOriginalGroupId()),
493                                                    
494                                                    journalArticleResourceModelImpl.getOriginalArticleId()
495                                            };
496    
497                                    FinderCacheUtil.removeResult(FINDER_PATH_COUNT_BY_G_A, args);
498    
499                                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_A, args);
500    
501                                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A,
502                                            new Object[] {
503                                                    Long.valueOf(journalArticleResource.getGroupId()),
504                                                    
505                                            journalArticleResource.getArticleId()
506                                            }, journalArticleResource);
507                            }
508                    }
509    
510                    return journalArticleResource;
511            }
512    
513            protected JournalArticleResource toUnwrappedModel(
514                    JournalArticleResource journalArticleResource) {
515                    if (journalArticleResource instanceof JournalArticleResourceImpl) {
516                            return journalArticleResource;
517                    }
518    
519                    JournalArticleResourceImpl journalArticleResourceImpl = new JournalArticleResourceImpl();
520    
521                    journalArticleResourceImpl.setNew(journalArticleResource.isNew());
522                    journalArticleResourceImpl.setPrimaryKey(journalArticleResource.getPrimaryKey());
523    
524                    journalArticleResourceImpl.setUuid(journalArticleResource.getUuid());
525                    journalArticleResourceImpl.setResourcePrimKey(journalArticleResource.getResourcePrimKey());
526                    journalArticleResourceImpl.setGroupId(journalArticleResource.getGroupId());
527                    journalArticleResourceImpl.setArticleId(journalArticleResource.getArticleId());
528    
529                    return journalArticleResourceImpl;
530            }
531    
532            /**
533             * Returns the journal article resource with the primary key or throws a {@link com.liferay.portal.NoSuchModelException} if it could not be found.
534             *
535             * @param primaryKey the primary key of the journal article resource
536             * @return the journal article resource
537             * @throws com.liferay.portal.NoSuchModelException if a journal article resource with the primary key could not be found
538             * @throws SystemException if a system exception occurred
539             */
540            @Override
541            public JournalArticleResource findByPrimaryKey(Serializable primaryKey)
542                    throws NoSuchModelException, SystemException {
543                    return findByPrimaryKey(((Long)primaryKey).longValue());
544            }
545    
546            /**
547             * Returns the journal article resource with the primary key or throws a {@link com.liferay.portlet.journal.NoSuchArticleResourceException} if it could not be found.
548             *
549             * @param resourcePrimKey the primary key of the journal article resource
550             * @return the journal article resource
551             * @throws com.liferay.portlet.journal.NoSuchArticleResourceException if a journal article resource with the primary key could not be found
552             * @throws SystemException if a system exception occurred
553             */
554            public JournalArticleResource findByPrimaryKey(long resourcePrimKey)
555                    throws NoSuchArticleResourceException, SystemException {
556                    JournalArticleResource journalArticleResource = fetchByPrimaryKey(resourcePrimKey);
557    
558                    if (journalArticleResource == null) {
559                            if (_log.isWarnEnabled()) {
560                                    _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + resourcePrimKey);
561                            }
562    
563                            throw new NoSuchArticleResourceException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
564                                    resourcePrimKey);
565                    }
566    
567                    return journalArticleResource;
568            }
569    
570            /**
571             * Returns the journal article resource with the primary key or returns <code>null</code> if it could not be found.
572             *
573             * @param primaryKey the primary key of the journal article resource
574             * @return the journal article resource, or <code>null</code> if a journal article resource with the primary key could not be found
575             * @throws SystemException if a system exception occurred
576             */
577            @Override
578            public JournalArticleResource fetchByPrimaryKey(Serializable primaryKey)
579                    throws SystemException {
580                    return fetchByPrimaryKey(((Long)primaryKey).longValue());
581            }
582    
583            /**
584             * Returns the journal article resource with the primary key or returns <code>null</code> if it could not be found.
585             *
586             * @param resourcePrimKey the primary key of the journal article resource
587             * @return the journal article resource, or <code>null</code> if a journal article resource with the primary key could not be found
588             * @throws SystemException if a system exception occurred
589             */
590            public JournalArticleResource fetchByPrimaryKey(long resourcePrimKey)
591                    throws SystemException {
592                    JournalArticleResource journalArticleResource = (JournalArticleResource)EntityCacheUtil.getResult(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
593                                    JournalArticleResourceImpl.class, resourcePrimKey);
594    
595                    if (journalArticleResource == _nullJournalArticleResource) {
596                            return null;
597                    }
598    
599                    if (journalArticleResource == null) {
600                            Session session = null;
601    
602                            boolean hasException = false;
603    
604                            try {
605                                    session = openSession();
606    
607                                    journalArticleResource = (JournalArticleResource)session.get(JournalArticleResourceImpl.class,
608                                                    Long.valueOf(resourcePrimKey));
609                            }
610                            catch (Exception e) {
611                                    hasException = true;
612    
613                                    throw processException(e);
614                            }
615                            finally {
616                                    if (journalArticleResource != null) {
617                                            cacheResult(journalArticleResource);
618                                    }
619                                    else if (!hasException) {
620                                            EntityCacheUtil.putResult(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
621                                                    JournalArticleResourceImpl.class, resourcePrimKey,
622                                                    _nullJournalArticleResource);
623                                    }
624    
625                                    closeSession(session);
626                            }
627                    }
628    
629                    return journalArticleResource;
630            }
631    
632            /**
633             * Returns all the journal article resources where uuid = &#63;.
634             *
635             * @param uuid the uuid
636             * @return the matching journal article resources
637             * @throws SystemException if a system exception occurred
638             */
639            public List<JournalArticleResource> findByUuid(String uuid)
640                    throws SystemException {
641                    return findByUuid(uuid, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
642            }
643    
644            /**
645             * Returns a range of all the journal article resources where uuid = &#63;.
646             *
647             * <p>
648             * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
649             * </p>
650             *
651             * @param uuid the uuid
652             * @param start the lower bound of the range of journal article resources
653             * @param end the upper bound of the range of journal article resources (not inclusive)
654             * @return the range of matching journal article resources
655             * @throws SystemException if a system exception occurred
656             */
657            public List<JournalArticleResource> findByUuid(String uuid, int start,
658                    int end) throws SystemException {
659                    return findByUuid(uuid, start, end, null);
660            }
661    
662            /**
663             * Returns an ordered range of all the journal article resources where uuid = &#63;.
664             *
665             * <p>
666             * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
667             * </p>
668             *
669             * @param uuid the uuid
670             * @param start the lower bound of the range of journal article resources
671             * @param end the upper bound of the range of journal article resources (not inclusive)
672             * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
673             * @return the ordered range of matching journal article resources
674             * @throws SystemException if a system exception occurred
675             */
676            public List<JournalArticleResource> findByUuid(String uuid, int start,
677                    int end, OrderByComparator orderByComparator) throws SystemException {
678                    FinderPath finderPath = null;
679                    Object[] finderArgs = null;
680    
681                    if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
682                                    (orderByComparator == null)) {
683                            finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_UUID;
684                            finderArgs = new Object[] { uuid };
685                    }
686                    else {
687                            finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_UUID;
688                            finderArgs = new Object[] { uuid, start, end, orderByComparator };
689                    }
690    
691                    List<JournalArticleResource> list = (List<JournalArticleResource>)FinderCacheUtil.getResult(finderPath,
692                                    finderArgs, this);
693    
694                    if ((list != null) && !list.isEmpty()) {
695                            for (JournalArticleResource journalArticleResource : list) {
696                                    if (!Validator.equals(uuid, journalArticleResource.getUuid())) {
697                                            list = null;
698    
699                                            break;
700                                    }
701                            }
702                    }
703    
704                    if (list == null) {
705                            StringBundler query = null;
706    
707                            if (orderByComparator != null) {
708                                    query = new StringBundler(3 +
709                                                    (orderByComparator.getOrderByFields().length * 3));
710                            }
711                            else {
712                                    query = new StringBundler(2);
713                            }
714    
715                            query.append(_SQL_SELECT_JOURNALARTICLERESOURCE_WHERE);
716    
717                            if (uuid == null) {
718                                    query.append(_FINDER_COLUMN_UUID_UUID_1);
719                            }
720                            else {
721                                    if (uuid.equals(StringPool.BLANK)) {
722                                            query.append(_FINDER_COLUMN_UUID_UUID_3);
723                                    }
724                                    else {
725                                            query.append(_FINDER_COLUMN_UUID_UUID_2);
726                                    }
727                            }
728    
729                            if (orderByComparator != null) {
730                                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
731                                            orderByComparator);
732                            }
733    
734                            String sql = query.toString();
735    
736                            Session session = null;
737    
738                            try {
739                                    session = openSession();
740    
741                                    Query q = session.createQuery(sql);
742    
743                                    QueryPos qPos = QueryPos.getInstance(q);
744    
745                                    if (uuid != null) {
746                                            qPos.add(uuid);
747                                    }
748    
749                                    list = (List<JournalArticleResource>)QueryUtil.list(q,
750                                                    getDialect(), start, end);
751                            }
752                            catch (Exception e) {
753                                    throw processException(e);
754                            }
755                            finally {
756                                    if (list == null) {
757                                            FinderCacheUtil.removeResult(finderPath, finderArgs);
758                                    }
759                                    else {
760                                            cacheResult(list);
761    
762                                            FinderCacheUtil.putResult(finderPath, finderArgs, list);
763                                    }
764    
765                                    closeSession(session);
766                            }
767                    }
768    
769                    return list;
770            }
771    
772            /**
773             * Returns the first journal article resource in the ordered set where uuid = &#63;.
774             *
775             * @param uuid the uuid
776             * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
777             * @return the first matching journal article resource
778             * @throws com.liferay.portlet.journal.NoSuchArticleResourceException if a matching journal article resource could not be found
779             * @throws SystemException if a system exception occurred
780             */
781            public JournalArticleResource findByUuid_First(String uuid,
782                    OrderByComparator orderByComparator)
783                    throws NoSuchArticleResourceException, SystemException {
784                    JournalArticleResource journalArticleResource = fetchByUuid_First(uuid,
785                                    orderByComparator);
786    
787                    if (journalArticleResource != null) {
788                            return journalArticleResource;
789                    }
790    
791                    StringBundler msg = new StringBundler(4);
792    
793                    msg.append(_NO_SUCH_ENTITY_WITH_KEY);
794    
795                    msg.append("uuid=");
796                    msg.append(uuid);
797    
798                    msg.append(StringPool.CLOSE_CURLY_BRACE);
799    
800                    throw new NoSuchArticleResourceException(msg.toString());
801            }
802    
803            /**
804             * Returns the first journal article resource in the ordered set where uuid = &#63;.
805             *
806             * @param uuid the uuid
807             * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
808             * @return the first matching journal article resource, or <code>null</code> if a matching journal article resource could not be found
809             * @throws SystemException if a system exception occurred
810             */
811            public JournalArticleResource fetchByUuid_First(String uuid,
812                    OrderByComparator orderByComparator) throws SystemException {
813                    List<JournalArticleResource> list = findByUuid(uuid, 0, 1,
814                                    orderByComparator);
815    
816                    if (!list.isEmpty()) {
817                            return list.get(0);
818                    }
819    
820                    return null;
821            }
822    
823            /**
824             * Returns the last journal article resource in the ordered set where uuid = &#63;.
825             *
826             * @param uuid the uuid
827             * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
828             * @return the last matching journal article resource
829             * @throws com.liferay.portlet.journal.NoSuchArticleResourceException if a matching journal article resource could not be found
830             * @throws SystemException if a system exception occurred
831             */
832            public JournalArticleResource findByUuid_Last(String uuid,
833                    OrderByComparator orderByComparator)
834                    throws NoSuchArticleResourceException, SystemException {
835                    JournalArticleResource journalArticleResource = fetchByUuid_Last(uuid,
836                                    orderByComparator);
837    
838                    if (journalArticleResource != null) {
839                            return journalArticleResource;
840                    }
841    
842                    StringBundler msg = new StringBundler(4);
843    
844                    msg.append(_NO_SUCH_ENTITY_WITH_KEY);
845    
846                    msg.append("uuid=");
847                    msg.append(uuid);
848    
849                    msg.append(StringPool.CLOSE_CURLY_BRACE);
850    
851                    throw new NoSuchArticleResourceException(msg.toString());
852            }
853    
854            /**
855             * Returns the last journal article resource in the ordered set where uuid = &#63;.
856             *
857             * @param uuid the uuid
858             * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
859             * @return the last matching journal article resource, or <code>null</code> if a matching journal article resource could not be found
860             * @throws SystemException if a system exception occurred
861             */
862            public JournalArticleResource fetchByUuid_Last(String uuid,
863                    OrderByComparator orderByComparator) throws SystemException {
864                    int count = countByUuid(uuid);
865    
866                    List<JournalArticleResource> list = findByUuid(uuid, count - 1, count,
867                                    orderByComparator);
868    
869                    if (!list.isEmpty()) {
870                            return list.get(0);
871                    }
872    
873                    return null;
874            }
875    
876            /**
877             * Returns the journal article resources before and after the current journal article resource in the ordered set where uuid = &#63;.
878             *
879             * @param resourcePrimKey the primary key of the current journal article resource
880             * @param uuid the uuid
881             * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
882             * @return the previous, current, and next journal article resource
883             * @throws com.liferay.portlet.journal.NoSuchArticleResourceException if a journal article resource with the primary key could not be found
884             * @throws SystemException if a system exception occurred
885             */
886            public JournalArticleResource[] findByUuid_PrevAndNext(
887                    long resourcePrimKey, String uuid, OrderByComparator orderByComparator)
888                    throws NoSuchArticleResourceException, SystemException {
889                    JournalArticleResource journalArticleResource = findByPrimaryKey(resourcePrimKey);
890    
891                    Session session = null;
892    
893                    try {
894                            session = openSession();
895    
896                            JournalArticleResource[] array = new JournalArticleResourceImpl[3];
897    
898                            array[0] = getByUuid_PrevAndNext(session, journalArticleResource,
899                                            uuid, orderByComparator, true);
900    
901                            array[1] = journalArticleResource;
902    
903                            array[2] = getByUuid_PrevAndNext(session, journalArticleResource,
904                                            uuid, orderByComparator, false);
905    
906                            return array;
907                    }
908                    catch (Exception e) {
909                            throw processException(e);
910                    }
911                    finally {
912                            closeSession(session);
913                    }
914            }
915    
916            protected JournalArticleResource getByUuid_PrevAndNext(Session session,
917                    JournalArticleResource journalArticleResource, String uuid,
918                    OrderByComparator orderByComparator, boolean previous) {
919                    StringBundler query = null;
920    
921                    if (orderByComparator != null) {
922                            query = new StringBundler(6 +
923                                            (orderByComparator.getOrderByFields().length * 6));
924                    }
925                    else {
926                            query = new StringBundler(3);
927                    }
928    
929                    query.append(_SQL_SELECT_JOURNALARTICLERESOURCE_WHERE);
930    
931                    if (uuid == null) {
932                            query.append(_FINDER_COLUMN_UUID_UUID_1);
933                    }
934                    else {
935                            if (uuid.equals(StringPool.BLANK)) {
936                                    query.append(_FINDER_COLUMN_UUID_UUID_3);
937                            }
938                            else {
939                                    query.append(_FINDER_COLUMN_UUID_UUID_2);
940                            }
941                    }
942    
943                    if (orderByComparator != null) {
944                            String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
945    
946                            if (orderByConditionFields.length > 0) {
947                                    query.append(WHERE_AND);
948                            }
949    
950                            for (int i = 0; i < orderByConditionFields.length; i++) {
951                                    query.append(_ORDER_BY_ENTITY_ALIAS);
952                                    query.append(orderByConditionFields[i]);
953    
954                                    if ((i + 1) < orderByConditionFields.length) {
955                                            if (orderByComparator.isAscending() ^ previous) {
956                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
957                                            }
958                                            else {
959                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
960                                            }
961                                    }
962                                    else {
963                                            if (orderByComparator.isAscending() ^ previous) {
964                                                    query.append(WHERE_GREATER_THAN);
965                                            }
966                                            else {
967                                                    query.append(WHERE_LESSER_THAN);
968                                            }
969                                    }
970                            }
971    
972                            query.append(ORDER_BY_CLAUSE);
973    
974                            String[] orderByFields = orderByComparator.getOrderByFields();
975    
976                            for (int i = 0; i < orderByFields.length; i++) {
977                                    query.append(_ORDER_BY_ENTITY_ALIAS);
978                                    query.append(orderByFields[i]);
979    
980                                    if ((i + 1) < orderByFields.length) {
981                                            if (orderByComparator.isAscending() ^ previous) {
982                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
983                                            }
984                                            else {
985                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
986                                            }
987                                    }
988                                    else {
989                                            if (orderByComparator.isAscending() ^ previous) {
990                                                    query.append(ORDER_BY_ASC);
991                                            }
992                                            else {
993                                                    query.append(ORDER_BY_DESC);
994                                            }
995                                    }
996                            }
997                    }
998    
999                    String sql = query.toString();
1000    
1001                    Query q = session.createQuery(sql);
1002    
1003                    q.setFirstResult(0);
1004                    q.setMaxResults(2);
1005    
1006                    QueryPos qPos = QueryPos.getInstance(q);
1007    
1008                    if (uuid != null) {
1009                            qPos.add(uuid);
1010                    }
1011    
1012                    if (orderByComparator != null) {
1013                            Object[] values = orderByComparator.getOrderByConditionValues(journalArticleResource);
1014    
1015                            for (Object value : values) {
1016                                    qPos.add(value);
1017                            }
1018                    }
1019    
1020                    List<JournalArticleResource> list = q.list();
1021    
1022                    if (list.size() == 2) {
1023                            return list.get(1);
1024                    }
1025                    else {
1026                            return null;
1027                    }
1028            }
1029    
1030            /**
1031             * Returns the journal article resource where uuid = &#63; and groupId = &#63; or throws a {@link com.liferay.portlet.journal.NoSuchArticleResourceException} if it could not be found.
1032             *
1033             * @param uuid the uuid
1034             * @param groupId the group ID
1035             * @return the matching journal article resource
1036             * @throws com.liferay.portlet.journal.NoSuchArticleResourceException if a matching journal article resource could not be found
1037             * @throws SystemException if a system exception occurred
1038             */
1039            public JournalArticleResource findByUUID_G(String uuid, long groupId)
1040                    throws NoSuchArticleResourceException, SystemException {
1041                    JournalArticleResource journalArticleResource = fetchByUUID_G(uuid,
1042                                    groupId);
1043    
1044                    if (journalArticleResource == null) {
1045                            StringBundler msg = new StringBundler(6);
1046    
1047                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1048    
1049                            msg.append("uuid=");
1050                            msg.append(uuid);
1051    
1052                            msg.append(", groupId=");
1053                            msg.append(groupId);
1054    
1055                            msg.append(StringPool.CLOSE_CURLY_BRACE);
1056    
1057                            if (_log.isWarnEnabled()) {
1058                                    _log.warn(msg.toString());
1059                            }
1060    
1061                            throw new NoSuchArticleResourceException(msg.toString());
1062                    }
1063    
1064                    return journalArticleResource;
1065            }
1066    
1067            /**
1068             * Returns the journal article resource where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1069             *
1070             * @param uuid the uuid
1071             * @param groupId the group ID
1072             * @return the matching journal article resource, or <code>null</code> if a matching journal article resource could not be found
1073             * @throws SystemException if a system exception occurred
1074             */
1075            public JournalArticleResource fetchByUUID_G(String uuid, long groupId)
1076                    throws SystemException {
1077                    return fetchByUUID_G(uuid, groupId, true);
1078            }
1079    
1080            /**
1081             * Returns the journal article resource where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1082             *
1083             * @param uuid the uuid
1084             * @param groupId the group ID
1085             * @param retrieveFromCache whether to use the finder cache
1086             * @return the matching journal article resource, or <code>null</code> if a matching journal article resource could not be found
1087             * @throws SystemException if a system exception occurred
1088             */
1089            public JournalArticleResource fetchByUUID_G(String uuid, long groupId,
1090                    boolean retrieveFromCache) throws SystemException {
1091                    Object[] finderArgs = new Object[] { uuid, groupId };
1092    
1093                    Object result = null;
1094    
1095                    if (retrieveFromCache) {
1096                            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_UUID_G,
1097                                            finderArgs, this);
1098                    }
1099    
1100                    if (result instanceof JournalArticleResource) {
1101                            JournalArticleResource journalArticleResource = (JournalArticleResource)result;
1102    
1103                            if (!Validator.equals(uuid, journalArticleResource.getUuid()) ||
1104                                            (groupId != journalArticleResource.getGroupId())) {
1105                                    result = null;
1106                            }
1107                    }
1108    
1109                    if (result == null) {
1110                            StringBundler query = new StringBundler(3);
1111    
1112                            query.append(_SQL_SELECT_JOURNALARTICLERESOURCE_WHERE);
1113    
1114                            if (uuid == null) {
1115                                    query.append(_FINDER_COLUMN_UUID_G_UUID_1);
1116                            }
1117                            else {
1118                                    if (uuid.equals(StringPool.BLANK)) {
1119                                            query.append(_FINDER_COLUMN_UUID_G_UUID_3);
1120                                    }
1121                                    else {
1122                                            query.append(_FINDER_COLUMN_UUID_G_UUID_2);
1123                                    }
1124                            }
1125    
1126                            query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
1127    
1128                            String sql = query.toString();
1129    
1130                            Session session = null;
1131    
1132                            try {
1133                                    session = openSession();
1134    
1135                                    Query q = session.createQuery(sql);
1136    
1137                                    QueryPos qPos = QueryPos.getInstance(q);
1138    
1139                                    if (uuid != null) {
1140                                            qPos.add(uuid);
1141                                    }
1142    
1143                                    qPos.add(groupId);
1144    
1145                                    List<JournalArticleResource> list = q.list();
1146    
1147                                    result = list;
1148    
1149                                    JournalArticleResource journalArticleResource = null;
1150    
1151                                    if (list.isEmpty()) {
1152                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
1153                                                    finderArgs, list);
1154                                    }
1155                                    else {
1156                                            journalArticleResource = list.get(0);
1157    
1158                                            cacheResult(journalArticleResource);
1159    
1160                                            if ((journalArticleResource.getUuid() == null) ||
1161                                                            !journalArticleResource.getUuid().equals(uuid) ||
1162                                                            (journalArticleResource.getGroupId() != groupId)) {
1163                                                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
1164                                                            finderArgs, journalArticleResource);
1165                                            }
1166                                    }
1167    
1168                                    return journalArticleResource;
1169                            }
1170                            catch (Exception e) {
1171                                    throw processException(e);
1172                            }
1173                            finally {
1174                                    if (result == null) {
1175                                            FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
1176                                                    finderArgs);
1177                                    }
1178    
1179                                    closeSession(session);
1180                            }
1181                    }
1182                    else {
1183                            if (result instanceof List<?>) {
1184                                    return null;
1185                            }
1186                            else {
1187                                    return (JournalArticleResource)result;
1188                            }
1189                    }
1190            }
1191    
1192            /**
1193             * Returns all the journal article resources where groupId = &#63;.
1194             *
1195             * @param groupId the group ID
1196             * @return the matching journal article resources
1197             * @throws SystemException if a system exception occurred
1198             */
1199            public List<JournalArticleResource> findByGroupId(long groupId)
1200                    throws SystemException {
1201                    return findByGroupId(groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1202            }
1203    
1204            /**
1205             * Returns a range of all the journal article resources where groupId = &#63;.
1206             *
1207             * <p>
1208             * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1209             * </p>
1210             *
1211             * @param groupId the group ID
1212             * @param start the lower bound of the range of journal article resources
1213             * @param end the upper bound of the range of journal article resources (not inclusive)
1214             * @return the range of matching journal article resources
1215             * @throws SystemException if a system exception occurred
1216             */
1217            public List<JournalArticleResource> findByGroupId(long groupId, int start,
1218                    int end) throws SystemException {
1219                    return findByGroupId(groupId, start, end, null);
1220            }
1221    
1222            /**
1223             * Returns an ordered range of all the journal article resources where groupId = &#63;.
1224             *
1225             * <p>
1226             * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1227             * </p>
1228             *
1229             * @param groupId the group ID
1230             * @param start the lower bound of the range of journal article resources
1231             * @param end the upper bound of the range of journal article resources (not inclusive)
1232             * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1233             * @return the ordered range of matching journal article resources
1234             * @throws SystemException if a system exception occurred
1235             */
1236            public List<JournalArticleResource> findByGroupId(long groupId, int start,
1237                    int end, OrderByComparator orderByComparator) throws SystemException {
1238                    FinderPath finderPath = null;
1239                    Object[] finderArgs = null;
1240    
1241                    if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
1242                                    (orderByComparator == null)) {
1243                            finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_BY_GROUPID;
1244                            finderArgs = new Object[] { groupId };
1245                    }
1246                    else {
1247                            finderPath = FINDER_PATH_WITH_PAGINATION_FIND_BY_GROUPID;
1248                            finderArgs = new Object[] { groupId, start, end, orderByComparator };
1249                    }
1250    
1251                    List<JournalArticleResource> list = (List<JournalArticleResource>)FinderCacheUtil.getResult(finderPath,
1252                                    finderArgs, this);
1253    
1254                    if ((list != null) && !list.isEmpty()) {
1255                            for (JournalArticleResource journalArticleResource : list) {
1256                                    if ((groupId != journalArticleResource.getGroupId())) {
1257                                            list = null;
1258    
1259                                            break;
1260                                    }
1261                            }
1262                    }
1263    
1264                    if (list == null) {
1265                            StringBundler query = null;
1266    
1267                            if (orderByComparator != null) {
1268                                    query = new StringBundler(3 +
1269                                                    (orderByComparator.getOrderByFields().length * 3));
1270                            }
1271                            else {
1272                                    query = new StringBundler(2);
1273                            }
1274    
1275                            query.append(_SQL_SELECT_JOURNALARTICLERESOURCE_WHERE);
1276    
1277                            query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1278    
1279                            if (orderByComparator != null) {
1280                                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1281                                            orderByComparator);
1282                            }
1283    
1284                            String sql = query.toString();
1285    
1286                            Session session = null;
1287    
1288                            try {
1289                                    session = openSession();
1290    
1291                                    Query q = session.createQuery(sql);
1292    
1293                                    QueryPos qPos = QueryPos.getInstance(q);
1294    
1295                                    qPos.add(groupId);
1296    
1297                                    list = (List<JournalArticleResource>)QueryUtil.list(q,
1298                                                    getDialect(), start, end);
1299                            }
1300                            catch (Exception e) {
1301                                    throw processException(e);
1302                            }
1303                            finally {
1304                                    if (list == null) {
1305                                            FinderCacheUtil.removeResult(finderPath, finderArgs);
1306                                    }
1307                                    else {
1308                                            cacheResult(list);
1309    
1310                                            FinderCacheUtil.putResult(finderPath, finderArgs, list);
1311                                    }
1312    
1313                                    closeSession(session);
1314                            }
1315                    }
1316    
1317                    return list;
1318            }
1319    
1320            /**
1321             * Returns the first journal article resource in the ordered set where groupId = &#63;.
1322             *
1323             * @param groupId the group ID
1324             * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1325             * @return the first matching journal article resource
1326             * @throws com.liferay.portlet.journal.NoSuchArticleResourceException if a matching journal article resource could not be found
1327             * @throws SystemException if a system exception occurred
1328             */
1329            public JournalArticleResource findByGroupId_First(long groupId,
1330                    OrderByComparator orderByComparator)
1331                    throws NoSuchArticleResourceException, SystemException {
1332                    JournalArticleResource journalArticleResource = fetchByGroupId_First(groupId,
1333                                    orderByComparator);
1334    
1335                    if (journalArticleResource != null) {
1336                            return journalArticleResource;
1337                    }
1338    
1339                    StringBundler msg = new StringBundler(4);
1340    
1341                    msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1342    
1343                    msg.append("groupId=");
1344                    msg.append(groupId);
1345    
1346                    msg.append(StringPool.CLOSE_CURLY_BRACE);
1347    
1348                    throw new NoSuchArticleResourceException(msg.toString());
1349            }
1350    
1351            /**
1352             * Returns the first journal article resource in the ordered set where groupId = &#63;.
1353             *
1354             * @param groupId the group ID
1355             * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1356             * @return the first matching journal article resource, or <code>null</code> if a matching journal article resource could not be found
1357             * @throws SystemException if a system exception occurred
1358             */
1359            public JournalArticleResource fetchByGroupId_First(long groupId,
1360                    OrderByComparator orderByComparator) throws SystemException {
1361                    List<JournalArticleResource> list = findByGroupId(groupId, 0, 1,
1362                                    orderByComparator);
1363    
1364                    if (!list.isEmpty()) {
1365                            return list.get(0);
1366                    }
1367    
1368                    return null;
1369            }
1370    
1371            /**
1372             * Returns the last journal article resource in the ordered set where groupId = &#63;.
1373             *
1374             * @param groupId the group ID
1375             * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1376             * @return the last matching journal article resource
1377             * @throws com.liferay.portlet.journal.NoSuchArticleResourceException if a matching journal article resource could not be found
1378             * @throws SystemException if a system exception occurred
1379             */
1380            public JournalArticleResource findByGroupId_Last(long groupId,
1381                    OrderByComparator orderByComparator)
1382                    throws NoSuchArticleResourceException, SystemException {
1383                    JournalArticleResource journalArticleResource = fetchByGroupId_Last(groupId,
1384                                    orderByComparator);
1385    
1386                    if (journalArticleResource != null) {
1387                            return journalArticleResource;
1388                    }
1389    
1390                    StringBundler msg = new StringBundler(4);
1391    
1392                    msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1393    
1394                    msg.append("groupId=");
1395                    msg.append(groupId);
1396    
1397                    msg.append(StringPool.CLOSE_CURLY_BRACE);
1398    
1399                    throw new NoSuchArticleResourceException(msg.toString());
1400            }
1401    
1402            /**
1403             * Returns the last journal article resource in the ordered set where groupId = &#63;.
1404             *
1405             * @param groupId the group ID
1406             * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1407             * @return the last matching journal article resource, or <code>null</code> if a matching journal article resource could not be found
1408             * @throws SystemException if a system exception occurred
1409             */
1410            public JournalArticleResource fetchByGroupId_Last(long groupId,
1411                    OrderByComparator orderByComparator) throws SystemException {
1412                    int count = countByGroupId(groupId);
1413    
1414                    List<JournalArticleResource> list = findByGroupId(groupId, count - 1,
1415                                    count, orderByComparator);
1416    
1417                    if (!list.isEmpty()) {
1418                            return list.get(0);
1419                    }
1420    
1421                    return null;
1422            }
1423    
1424            /**
1425             * Returns the journal article resources before and after the current journal article resource in the ordered set where groupId = &#63;.
1426             *
1427             * @param resourcePrimKey the primary key of the current journal article resource
1428             * @param groupId the group ID
1429             * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1430             * @return the previous, current, and next journal article resource
1431             * @throws com.liferay.portlet.journal.NoSuchArticleResourceException if a journal article resource with the primary key could not be found
1432             * @throws SystemException if a system exception occurred
1433             */
1434            public JournalArticleResource[] findByGroupId_PrevAndNext(
1435                    long resourcePrimKey, long groupId, OrderByComparator orderByComparator)
1436                    throws NoSuchArticleResourceException, SystemException {
1437                    JournalArticleResource journalArticleResource = findByPrimaryKey(resourcePrimKey);
1438    
1439                    Session session = null;
1440    
1441                    try {
1442                            session = openSession();
1443    
1444                            JournalArticleResource[] array = new JournalArticleResourceImpl[3];
1445    
1446                            array[0] = getByGroupId_PrevAndNext(session,
1447                                            journalArticleResource, groupId, orderByComparator, true);
1448    
1449                            array[1] = journalArticleResource;
1450    
1451                            array[2] = getByGroupId_PrevAndNext(session,
1452                                            journalArticleResource, groupId, orderByComparator, false);
1453    
1454                            return array;
1455                    }
1456                    catch (Exception e) {
1457                            throw processException(e);
1458                    }
1459                    finally {
1460                            closeSession(session);
1461                    }
1462            }
1463    
1464            protected JournalArticleResource getByGroupId_PrevAndNext(Session session,
1465                    JournalArticleResource journalArticleResource, long groupId,
1466                    OrderByComparator orderByComparator, boolean previous) {
1467                    StringBundler query = null;
1468    
1469                    if (orderByComparator != null) {
1470                            query = new StringBundler(6 +
1471                                            (orderByComparator.getOrderByFields().length * 6));
1472                    }
1473                    else {
1474                            query = new StringBundler(3);
1475                    }
1476    
1477                    query.append(_SQL_SELECT_JOURNALARTICLERESOURCE_WHERE);
1478    
1479                    query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1480    
1481                    if (orderByComparator != null) {
1482                            String[] orderByConditionFields = orderByComparator.getOrderByConditionFields();
1483    
1484                            if (orderByConditionFields.length > 0) {
1485                                    query.append(WHERE_AND);
1486                            }
1487    
1488                            for (int i = 0; i < orderByConditionFields.length; i++) {
1489                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1490                                    query.append(orderByConditionFields[i]);
1491    
1492                                    if ((i + 1) < orderByConditionFields.length) {
1493                                            if (orderByComparator.isAscending() ^ previous) {
1494                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
1495                                            }
1496                                            else {
1497                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
1498                                            }
1499                                    }
1500                                    else {
1501                                            if (orderByComparator.isAscending() ^ previous) {
1502                                                    query.append(WHERE_GREATER_THAN);
1503                                            }
1504                                            else {
1505                                                    query.append(WHERE_LESSER_THAN);
1506                                            }
1507                                    }
1508                            }
1509    
1510                            query.append(ORDER_BY_CLAUSE);
1511    
1512                            String[] orderByFields = orderByComparator.getOrderByFields();
1513    
1514                            for (int i = 0; i < orderByFields.length; i++) {
1515                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1516                                    query.append(orderByFields[i]);
1517    
1518                                    if ((i + 1) < orderByFields.length) {
1519                                            if (orderByComparator.isAscending() ^ previous) {
1520                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
1521                                            }
1522                                            else {
1523                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
1524                                            }
1525                                    }
1526                                    else {
1527                                            if (orderByComparator.isAscending() ^ previous) {
1528                                                    query.append(ORDER_BY_ASC);
1529                                            }
1530                                            else {
1531                                                    query.append(ORDER_BY_DESC);
1532                                            }
1533                                    }
1534                            }
1535                    }
1536    
1537                    String sql = query.toString();
1538    
1539                    Query q = session.createQuery(sql);
1540    
1541                    q.setFirstResult(0);
1542                    q.setMaxResults(2);
1543    
1544                    QueryPos qPos = QueryPos.getInstance(q);
1545    
1546                    qPos.add(groupId);
1547    
1548                    if (orderByComparator != null) {
1549                            Object[] values = orderByComparator.getOrderByConditionValues(journalArticleResource);
1550    
1551                            for (Object value : values) {
1552                                    qPos.add(value);
1553                            }
1554                    }
1555    
1556                    List<JournalArticleResource> list = q.list();
1557    
1558                    if (list.size() == 2) {
1559                            return list.get(1);
1560                    }
1561                    else {
1562                            return null;
1563                    }
1564            }
1565    
1566            /**
1567             * Returns the journal article resource where groupId = &#63; and articleId = &#63; or throws a {@link com.liferay.portlet.journal.NoSuchArticleResourceException} if it could not be found.
1568             *
1569             * @param groupId the group ID
1570             * @param articleId the article ID
1571             * @return the matching journal article resource
1572             * @throws com.liferay.portlet.journal.NoSuchArticleResourceException if a matching journal article resource could not be found
1573             * @throws SystemException if a system exception occurred
1574             */
1575            public JournalArticleResource findByG_A(long groupId, String articleId)
1576                    throws NoSuchArticleResourceException, SystemException {
1577                    JournalArticleResource journalArticleResource = fetchByG_A(groupId,
1578                                    articleId);
1579    
1580                    if (journalArticleResource == null) {
1581                            StringBundler msg = new StringBundler(6);
1582    
1583                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1584    
1585                            msg.append("groupId=");
1586                            msg.append(groupId);
1587    
1588                            msg.append(", articleId=");
1589                            msg.append(articleId);
1590    
1591                            msg.append(StringPool.CLOSE_CURLY_BRACE);
1592    
1593                            if (_log.isWarnEnabled()) {
1594                                    _log.warn(msg.toString());
1595                            }
1596    
1597                            throw new NoSuchArticleResourceException(msg.toString());
1598                    }
1599    
1600                    return journalArticleResource;
1601            }
1602    
1603            /**
1604             * Returns the journal article resource where groupId = &#63; and articleId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1605             *
1606             * @param groupId the group ID
1607             * @param articleId the article ID
1608             * @return the matching journal article resource, or <code>null</code> if a matching journal article resource could not be found
1609             * @throws SystemException if a system exception occurred
1610             */
1611            public JournalArticleResource fetchByG_A(long groupId, String articleId)
1612                    throws SystemException {
1613                    return fetchByG_A(groupId, articleId, true);
1614            }
1615    
1616            /**
1617             * Returns the journal article resource where groupId = &#63; and articleId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1618             *
1619             * @param groupId the group ID
1620             * @param articleId the article ID
1621             * @param retrieveFromCache whether to use the finder cache
1622             * @return the matching journal article resource, or <code>null</code> if a matching journal article resource could not be found
1623             * @throws SystemException if a system exception occurred
1624             */
1625            public JournalArticleResource fetchByG_A(long groupId, String articleId,
1626                    boolean retrieveFromCache) throws SystemException {
1627                    Object[] finderArgs = new Object[] { groupId, articleId };
1628    
1629                    Object result = null;
1630    
1631                    if (retrieveFromCache) {
1632                            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_G_A,
1633                                            finderArgs, this);
1634                    }
1635    
1636                    if (result instanceof JournalArticleResource) {
1637                            JournalArticleResource journalArticleResource = (JournalArticleResource)result;
1638    
1639                            if ((groupId != journalArticleResource.getGroupId()) ||
1640                                            !Validator.equals(articleId,
1641                                                    journalArticleResource.getArticleId())) {
1642                                    result = null;
1643                            }
1644                    }
1645    
1646                    if (result == null) {
1647                            StringBundler query = new StringBundler(3);
1648    
1649                            query.append(_SQL_SELECT_JOURNALARTICLERESOURCE_WHERE);
1650    
1651                            query.append(_FINDER_COLUMN_G_A_GROUPID_2);
1652    
1653                            if (articleId == null) {
1654                                    query.append(_FINDER_COLUMN_G_A_ARTICLEID_1);
1655                            }
1656                            else {
1657                                    if (articleId.equals(StringPool.BLANK)) {
1658                                            query.append(_FINDER_COLUMN_G_A_ARTICLEID_3);
1659                                    }
1660                                    else {
1661                                            query.append(_FINDER_COLUMN_G_A_ARTICLEID_2);
1662                                    }
1663                            }
1664    
1665                            String sql = query.toString();
1666    
1667                            Session session = null;
1668    
1669                            try {
1670                                    session = openSession();
1671    
1672                                    Query q = session.createQuery(sql);
1673    
1674                                    QueryPos qPos = QueryPos.getInstance(q);
1675    
1676                                    qPos.add(groupId);
1677    
1678                                    if (articleId != null) {
1679                                            qPos.add(articleId);
1680                                    }
1681    
1682                                    List<JournalArticleResource> list = q.list();
1683    
1684                                    result = list;
1685    
1686                                    JournalArticleResource journalArticleResource = null;
1687    
1688                                    if (list.isEmpty()) {
1689                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A,
1690                                                    finderArgs, list);
1691                                    }
1692                                    else {
1693                                            journalArticleResource = list.get(0);
1694    
1695                                            cacheResult(journalArticleResource);
1696    
1697                                            if ((journalArticleResource.getGroupId() != groupId) ||
1698                                                            (journalArticleResource.getArticleId() == null) ||
1699                                                            !journalArticleResource.getArticleId()
1700                                                                                                               .equals(articleId)) {
1701                                                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A,
1702                                                            finderArgs, journalArticleResource);
1703                                            }
1704                                    }
1705    
1706                                    return journalArticleResource;
1707                            }
1708                            catch (Exception e) {
1709                                    throw processException(e);
1710                            }
1711                            finally {
1712                                    if (result == null) {
1713                                            FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_A,
1714                                                    finderArgs);
1715                                    }
1716    
1717                                    closeSession(session);
1718                            }
1719                    }
1720                    else {
1721                            if (result instanceof List<?>) {
1722                                    return null;
1723                            }
1724                            else {
1725                                    return (JournalArticleResource)result;
1726                            }
1727                    }
1728            }
1729    
1730            /**
1731             * Returns all the journal article resources.
1732             *
1733             * @return the journal article resources
1734             * @throws SystemException if a system exception occurred
1735             */
1736            public List<JournalArticleResource> findAll() throws SystemException {
1737                    return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1738            }
1739    
1740            /**
1741             * Returns a range of all the journal article resources.
1742             *
1743             * <p>
1744             * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1745             * </p>
1746             *
1747             * @param start the lower bound of the range of journal article resources
1748             * @param end the upper bound of the range of journal article resources (not inclusive)
1749             * @return the range of journal article resources
1750             * @throws SystemException if a system exception occurred
1751             */
1752            public List<JournalArticleResource> findAll(int start, int end)
1753                    throws SystemException {
1754                    return findAll(start, end, null);
1755            }
1756    
1757            /**
1758             * Returns an ordered range of all the journal article resources.
1759             *
1760             * <p>
1761             * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1762             * </p>
1763             *
1764             * @param start the lower bound of the range of journal article resources
1765             * @param end the upper bound of the range of journal article resources (not inclusive)
1766             * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1767             * @return the ordered range of journal article resources
1768             * @throws SystemException if a system exception occurred
1769             */
1770            public List<JournalArticleResource> findAll(int start, int end,
1771                    OrderByComparator orderByComparator) throws SystemException {
1772                    FinderPath finderPath = null;
1773                    Object[] finderArgs = new Object[] { start, end, orderByComparator };
1774    
1775                    if ((start == QueryUtil.ALL_POS) && (end == QueryUtil.ALL_POS) &&
1776                                    (orderByComparator == null)) {
1777                            finderPath = FINDER_PATH_WITHOUT_PAGINATION_FIND_ALL;
1778                            finderArgs = FINDER_ARGS_EMPTY;
1779                    }
1780                    else {
1781                            finderPath = FINDER_PATH_WITH_PAGINATION_FIND_ALL;
1782                            finderArgs = new Object[] { start, end, orderByComparator };
1783                    }
1784    
1785                    List<JournalArticleResource> list = (List<JournalArticleResource>)FinderCacheUtil.getResult(finderPath,
1786                                    finderArgs, this);
1787    
1788                    if (list == null) {
1789                            StringBundler query = null;
1790                            String sql = null;
1791    
1792                            if (orderByComparator != null) {
1793                                    query = new StringBundler(2 +
1794                                                    (orderByComparator.getOrderByFields().length * 3));
1795    
1796                                    query.append(_SQL_SELECT_JOURNALARTICLERESOURCE);
1797    
1798                                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1799                                            orderByComparator);
1800    
1801                                    sql = query.toString();
1802                            }
1803                            else {
1804                                    sql = _SQL_SELECT_JOURNALARTICLERESOURCE;
1805                            }
1806    
1807                            Session session = null;
1808    
1809                            try {
1810                                    session = openSession();
1811    
1812                                    Query q = session.createQuery(sql);
1813    
1814                                    if (orderByComparator == null) {
1815                                            list = (List<JournalArticleResource>)QueryUtil.list(q,
1816                                                            getDialect(), start, end, false);
1817    
1818                                            Collections.sort(list);
1819                                    }
1820                                    else {
1821                                            list = (List<JournalArticleResource>)QueryUtil.list(q,
1822                                                            getDialect(), start, end);
1823                                    }
1824                            }
1825                            catch (Exception e) {
1826                                    throw processException(e);
1827                            }
1828                            finally {
1829                                    if (list == null) {
1830                                            FinderCacheUtil.removeResult(finderPath, finderArgs);
1831                                    }
1832                                    else {
1833                                            cacheResult(list);
1834    
1835                                            FinderCacheUtil.putResult(finderPath, finderArgs, list);
1836                                    }
1837    
1838                                    closeSession(session);
1839                            }
1840                    }
1841    
1842                    return list;
1843            }
1844    
1845            /**
1846             * Removes all the journal article resources where uuid = &#63; from the database.
1847             *
1848             * @param uuid the uuid
1849             * @throws SystemException if a system exception occurred
1850             */
1851            public void removeByUuid(String uuid) throws SystemException {
1852                    for (JournalArticleResource journalArticleResource : findByUuid(uuid)) {
1853                            remove(journalArticleResource);
1854                    }
1855            }
1856    
1857            /**
1858             * Removes the journal article resource where uuid = &#63; and groupId = &#63; from the database.
1859             *
1860             * @param uuid the uuid
1861             * @param groupId the group ID
1862             * @return the journal article resource that was removed
1863             * @throws SystemException if a system exception occurred
1864             */
1865            public JournalArticleResource removeByUUID_G(String uuid, long groupId)
1866                    throws NoSuchArticleResourceException, SystemException {
1867                    JournalArticleResource journalArticleResource = findByUUID_G(uuid,
1868                                    groupId);
1869    
1870                    return remove(journalArticleResource);
1871            }
1872    
1873            /**
1874             * Removes all the journal article resources where groupId = &#63; from the database.
1875             *
1876             * @param groupId the group ID
1877             * @throws SystemException if a system exception occurred
1878             */
1879            public void removeByGroupId(long groupId) throws SystemException {
1880                    for (JournalArticleResource journalArticleResource : findByGroupId(
1881                                    groupId)) {
1882                            remove(journalArticleResource);
1883                    }
1884            }
1885    
1886            /**
1887             * Removes the journal article resource where groupId = &#63; and articleId = &#63; from the database.
1888             *
1889             * @param groupId the group ID
1890             * @param articleId the article ID
1891             * @return the journal article resource that was removed
1892             * @throws SystemException if a system exception occurred
1893             */
1894            public JournalArticleResource removeByG_A(long groupId, String articleId)
1895                    throws NoSuchArticleResourceException, SystemException {
1896                    JournalArticleResource journalArticleResource = findByG_A(groupId,
1897                                    articleId);
1898    
1899                    return remove(journalArticleResource);
1900            }
1901    
1902            /**
1903             * Removes all the journal article resources from the database.
1904             *
1905             * @throws SystemException if a system exception occurred
1906             */
1907            public void removeAll() throws SystemException {
1908                    for (JournalArticleResource journalArticleResource : findAll()) {
1909                            remove(journalArticleResource);
1910                    }
1911            }
1912    
1913            /**
1914             * Returns the number of journal article resources where uuid = &#63;.
1915             *
1916             * @param uuid the uuid
1917             * @return the number of matching journal article resources
1918             * @throws SystemException if a system exception occurred
1919             */
1920            public int countByUuid(String uuid) throws SystemException {
1921                    Object[] finderArgs = new Object[] { uuid };
1922    
1923                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_UUID,
1924                                    finderArgs, this);
1925    
1926                    if (count == null) {
1927                            StringBundler query = new StringBundler(2);
1928    
1929                            query.append(_SQL_COUNT_JOURNALARTICLERESOURCE_WHERE);
1930    
1931                            if (uuid == null) {
1932                                    query.append(_FINDER_COLUMN_UUID_UUID_1);
1933                            }
1934                            else {
1935                                    if (uuid.equals(StringPool.BLANK)) {
1936                                            query.append(_FINDER_COLUMN_UUID_UUID_3);
1937                                    }
1938                                    else {
1939                                            query.append(_FINDER_COLUMN_UUID_UUID_2);
1940                                    }
1941                            }
1942    
1943                            String sql = query.toString();
1944    
1945                            Session session = null;
1946    
1947                            try {
1948                                    session = openSession();
1949    
1950                                    Query q = session.createQuery(sql);
1951    
1952                                    QueryPos qPos = QueryPos.getInstance(q);
1953    
1954                                    if (uuid != null) {
1955                                            qPos.add(uuid);
1956                                    }
1957    
1958                                    count = (Long)q.uniqueResult();
1959                            }
1960                            catch (Exception e) {
1961                                    throw processException(e);
1962                            }
1963                            finally {
1964                                    if (count == null) {
1965                                            count = Long.valueOf(0);
1966                                    }
1967    
1968                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID,
1969                                            finderArgs, count);
1970    
1971                                    closeSession(session);
1972                            }
1973                    }
1974    
1975                    return count.intValue();
1976            }
1977    
1978            /**
1979             * Returns the number of journal article resources where uuid = &#63; and groupId = &#63;.
1980             *
1981             * @param uuid the uuid
1982             * @param groupId the group ID
1983             * @return the number of matching journal article resources
1984             * @throws SystemException if a system exception occurred
1985             */
1986            public int countByUUID_G(String uuid, long groupId)
1987                    throws SystemException {
1988                    Object[] finderArgs = new Object[] { uuid, groupId };
1989    
1990                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_UUID_G,
1991                                    finderArgs, this);
1992    
1993                    if (count == null) {
1994                            StringBundler query = new StringBundler(3);
1995    
1996                            query.append(_SQL_COUNT_JOURNALARTICLERESOURCE_WHERE);
1997    
1998                            if (uuid == null) {
1999                                    query.append(_FINDER_COLUMN_UUID_G_UUID_1);
2000                            }
2001                            else {
2002                                    if (uuid.equals(StringPool.BLANK)) {
2003                                            query.append(_FINDER_COLUMN_UUID_G_UUID_3);
2004                                    }
2005                                    else {
2006                                            query.append(_FINDER_COLUMN_UUID_G_UUID_2);
2007                                    }
2008                            }
2009    
2010                            query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
2011    
2012                            String sql = query.toString();
2013    
2014                            Session session = null;
2015    
2016                            try {
2017                                    session = openSession();
2018    
2019                                    Query q = session.createQuery(sql);
2020    
2021                                    QueryPos qPos = QueryPos.getInstance(q);
2022    
2023                                    if (uuid != null) {
2024                                            qPos.add(uuid);
2025                                    }
2026    
2027                                    qPos.add(groupId);
2028    
2029                                    count = (Long)q.uniqueResult();
2030                            }
2031                            catch (Exception e) {
2032                                    throw processException(e);
2033                            }
2034                            finally {
2035                                    if (count == null) {
2036                                            count = Long.valueOf(0);
2037                                    }
2038    
2039                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID_G,
2040                                            finderArgs, count);
2041    
2042                                    closeSession(session);
2043                            }
2044                    }
2045    
2046                    return count.intValue();
2047            }
2048    
2049            /**
2050             * Returns the number of journal article resources where groupId = &#63;.
2051             *
2052             * @param groupId the group ID
2053             * @return the number of matching journal article resources
2054             * @throws SystemException if a system exception occurred
2055             */
2056            public int countByGroupId(long groupId) throws SystemException {
2057                    Object[] finderArgs = new Object[] { groupId };
2058    
2059                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_GROUPID,
2060                                    finderArgs, this);
2061    
2062                    if (count == null) {
2063                            StringBundler query = new StringBundler(2);
2064    
2065                            query.append(_SQL_COUNT_JOURNALARTICLERESOURCE_WHERE);
2066    
2067                            query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
2068    
2069                            String sql = query.toString();
2070    
2071                            Session session = null;
2072    
2073                            try {
2074                                    session = openSession();
2075    
2076                                    Query q = session.createQuery(sql);
2077    
2078                                    QueryPos qPos = QueryPos.getInstance(q);
2079    
2080                                    qPos.add(groupId);
2081    
2082                                    count = (Long)q.uniqueResult();
2083                            }
2084                            catch (Exception e) {
2085                                    throw processException(e);
2086                            }
2087                            finally {
2088                                    if (count == null) {
2089                                            count = Long.valueOf(0);
2090                                    }
2091    
2092                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_GROUPID,
2093                                            finderArgs, count);
2094    
2095                                    closeSession(session);
2096                            }
2097                    }
2098    
2099                    return count.intValue();
2100            }
2101    
2102            /**
2103             * Returns the number of journal article resources where groupId = &#63; and articleId = &#63;.
2104             *
2105             * @param groupId the group ID
2106             * @param articleId the article ID
2107             * @return the number of matching journal article resources
2108             * @throws SystemException if a system exception occurred
2109             */
2110            public int countByG_A(long groupId, String articleId)
2111                    throws SystemException {
2112                    Object[] finderArgs = new Object[] { groupId, articleId };
2113    
2114                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_A,
2115                                    finderArgs, this);
2116    
2117                    if (count == null) {
2118                            StringBundler query = new StringBundler(3);
2119    
2120                            query.append(_SQL_COUNT_JOURNALARTICLERESOURCE_WHERE);
2121    
2122                            query.append(_FINDER_COLUMN_G_A_GROUPID_2);
2123    
2124                            if (articleId == null) {
2125                                    query.append(_FINDER_COLUMN_G_A_ARTICLEID_1);
2126                            }
2127                            else {
2128                                    if (articleId.equals(StringPool.BLANK)) {
2129                                            query.append(_FINDER_COLUMN_G_A_ARTICLEID_3);
2130                                    }
2131                                    else {
2132                                            query.append(_FINDER_COLUMN_G_A_ARTICLEID_2);
2133                                    }
2134                            }
2135    
2136                            String sql = query.toString();
2137    
2138                            Session session = null;
2139    
2140                            try {
2141                                    session = openSession();
2142    
2143                                    Query q = session.createQuery(sql);
2144    
2145                                    QueryPos qPos = QueryPos.getInstance(q);
2146    
2147                                    qPos.add(groupId);
2148    
2149                                    if (articleId != null) {
2150                                            qPos.add(articleId);
2151                                    }
2152    
2153                                    count = (Long)q.uniqueResult();
2154                            }
2155                            catch (Exception e) {
2156                                    throw processException(e);
2157                            }
2158                            finally {
2159                                    if (count == null) {
2160                                            count = Long.valueOf(0);
2161                                    }
2162    
2163                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_A, finderArgs,
2164                                            count);
2165    
2166                                    closeSession(session);
2167                            }
2168                    }
2169    
2170                    return count.intValue();
2171            }
2172    
2173            /**
2174             * Returns the number of journal article resources.
2175             *
2176             * @return the number of journal article resources
2177             * @throws SystemException if a system exception occurred
2178             */
2179            public int countAll() throws SystemException {
2180                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
2181                                    FINDER_ARGS_EMPTY, this);
2182    
2183                    if (count == null) {
2184                            Session session = null;
2185    
2186                            try {
2187                                    session = openSession();
2188    
2189                                    Query q = session.createQuery(_SQL_COUNT_JOURNALARTICLERESOURCE);
2190    
2191                                    count = (Long)q.uniqueResult();
2192                            }
2193                            catch (Exception e) {
2194                                    throw processException(e);
2195                            }
2196                            finally {
2197                                    if (count == null) {
2198                                            count = Long.valueOf(0);
2199                                    }
2200    
2201                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL,
2202                                            FINDER_ARGS_EMPTY, count);
2203    
2204                                    closeSession(session);
2205                            }
2206                    }
2207    
2208                    return count.intValue();
2209            }
2210    
2211            /**
2212             * Initializes the journal article resource persistence.
2213             */
2214            public void afterPropertiesSet() {
2215                    String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
2216                                            com.liferay.portal.util.PropsUtil.get(
2217                                                    "value.object.listener.com.liferay.portlet.journal.model.JournalArticleResource")));
2218    
2219                    if (listenerClassNames.length > 0) {
2220                            try {
2221                                    List<ModelListener<JournalArticleResource>> listenersList = new ArrayList<ModelListener<JournalArticleResource>>();
2222    
2223                                    for (String listenerClassName : listenerClassNames) {
2224                                            listenersList.add((ModelListener<JournalArticleResource>)InstanceFactory.newInstance(
2225                                                            listenerClassName));
2226                                    }
2227    
2228                                    listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
2229                            }
2230                            catch (Exception e) {
2231                                    _log.error(e);
2232                            }
2233                    }
2234            }
2235    
2236            public void destroy() {
2237                    EntityCacheUtil.removeCache(JournalArticleResourceImpl.class.getName());
2238                    FinderCacheUtil.removeCache(FINDER_CLASS_NAME_ENTITY);
2239                    FinderCacheUtil.removeCache(FINDER_CLASS_NAME_LIST_WITHOUT_PAGINATION);
2240            }
2241    
2242            @BeanReference(type = JournalArticlePersistence.class)
2243            protected JournalArticlePersistence journalArticlePersistence;
2244            @BeanReference(type = JournalArticleImagePersistence.class)
2245            protected JournalArticleImagePersistence journalArticleImagePersistence;
2246            @BeanReference(type = JournalArticleResourcePersistence.class)
2247            protected JournalArticleResourcePersistence journalArticleResourcePersistence;
2248            @BeanReference(type = JournalContentSearchPersistence.class)
2249            protected JournalContentSearchPersistence journalContentSearchPersistence;
2250            @BeanReference(type = JournalFeedPersistence.class)
2251            protected JournalFeedPersistence journalFeedPersistence;
2252            @BeanReference(type = JournalFolderPersistence.class)
2253            protected JournalFolderPersistence journalFolderPersistence;
2254            @BeanReference(type = JournalStructurePersistence.class)
2255            protected JournalStructurePersistence journalStructurePersistence;
2256            @BeanReference(type = JournalTemplatePersistence.class)
2257            protected JournalTemplatePersistence journalTemplatePersistence;
2258            @BeanReference(type = UserPersistence.class)
2259            protected UserPersistence userPersistence;
2260            private static final String _SQL_SELECT_JOURNALARTICLERESOURCE = "SELECT journalArticleResource FROM JournalArticleResource journalArticleResource";
2261            private static final String _SQL_SELECT_JOURNALARTICLERESOURCE_WHERE = "SELECT journalArticleResource FROM JournalArticleResource journalArticleResource WHERE ";
2262            private static final String _SQL_COUNT_JOURNALARTICLERESOURCE = "SELECT COUNT(journalArticleResource) FROM JournalArticleResource journalArticleResource";
2263            private static final String _SQL_COUNT_JOURNALARTICLERESOURCE_WHERE = "SELECT COUNT(journalArticleResource) FROM JournalArticleResource journalArticleResource WHERE ";
2264            private static final String _FINDER_COLUMN_UUID_UUID_1 = "journalArticleResource.uuid IS NULL";
2265            private static final String _FINDER_COLUMN_UUID_UUID_2 = "journalArticleResource.uuid = ?";
2266            private static final String _FINDER_COLUMN_UUID_UUID_3 = "(journalArticleResource.uuid IS NULL OR journalArticleResource.uuid = ?)";
2267            private static final String _FINDER_COLUMN_UUID_G_UUID_1 = "journalArticleResource.uuid IS NULL AND ";
2268            private static final String _FINDER_COLUMN_UUID_G_UUID_2 = "journalArticleResource.uuid = ? AND ";
2269            private static final String _FINDER_COLUMN_UUID_G_UUID_3 = "(journalArticleResource.uuid IS NULL OR journalArticleResource.uuid = ?) AND ";
2270            private static final String _FINDER_COLUMN_UUID_G_GROUPID_2 = "journalArticleResource.groupId = ?";
2271            private static final String _FINDER_COLUMN_GROUPID_GROUPID_2 = "journalArticleResource.groupId = ?";
2272            private static final String _FINDER_COLUMN_G_A_GROUPID_2 = "journalArticleResource.groupId = ? AND ";
2273            private static final String _FINDER_COLUMN_G_A_ARTICLEID_1 = "journalArticleResource.articleId IS NULL";
2274            private static final String _FINDER_COLUMN_G_A_ARTICLEID_2 = "journalArticleResource.articleId = ?";
2275            private static final String _FINDER_COLUMN_G_A_ARTICLEID_3 = "(journalArticleResource.articleId IS NULL OR journalArticleResource.articleId = ?)";
2276            private static final String _ORDER_BY_ENTITY_ALIAS = "journalArticleResource.";
2277            private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No JournalArticleResource exists with the primary key ";
2278            private static final String _NO_SUCH_ENTITY_WITH_KEY = "No JournalArticleResource exists with the key {";
2279            private static final boolean _HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE = com.liferay.portal.util.PropsValues.HIBERNATE_CACHE_USE_SECOND_LEVEL_CACHE;
2280            private static Log _log = LogFactoryUtil.getLog(JournalArticleResourcePersistenceImpl.class);
2281            private static JournalArticleResource _nullJournalArticleResource = new JournalArticleResourceImpl() {
2282                            @Override
2283                            public Object clone() {
2284                                    return this;
2285                            }
2286    
2287                            @Override
2288                            public CacheModel<JournalArticleResource> toCacheModel() {
2289                                    return _nullJournalArticleResourceCacheModel;
2290                            }
2291                    };
2292    
2293            private static CacheModel<JournalArticleResource> _nullJournalArticleResourceCacheModel =
2294                    new CacheModel<JournalArticleResource>() {
2295                            public JournalArticleResource toEntityModel() {
2296                                    return _nullJournalArticleResource;
2297                            }
2298                    };
2299    }