001    /**
002     * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.journal.service.persistence;
016    
017    import com.liferay.portal.NoSuchModelException;
018    import com.liferay.portal.kernel.annotation.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.model.ModelListener;
038    import com.liferay.portal.service.persistence.BatchSessionUtil;
039    import com.liferay.portal.service.persistence.ResourcePersistence;
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     * @author    Brian Wing Shun Chan
056     * @see       JournalArticleResourcePersistence
057     * @see       JournalArticleResourceUtil
058     * @generated
059     */
060    public class JournalArticleResourcePersistenceImpl extends BasePersistenceImpl<JournalArticleResource>
061            implements JournalArticleResourcePersistence {
062            public static final String FINDER_CLASS_NAME_ENTITY = JournalArticleResourceImpl.class.getName();
063            public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
064                    ".List";
065            public static final FinderPath FINDER_PATH_FIND_BY_GROUPID = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
066                            JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
067                            FINDER_CLASS_NAME_LIST, "findByGroupId",
068                            new String[] {
069                                    Long.class.getName(),
070                                    
071                            "java.lang.Integer", "java.lang.Integer",
072                                    "com.liferay.portal.kernel.util.OrderByComparator"
073                            });
074            public static final FinderPath FINDER_PATH_COUNT_BY_GROUPID = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
075                            JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
076                            FINDER_CLASS_NAME_LIST, "countByGroupId",
077                            new String[] { Long.class.getName() });
078            public static final FinderPath FINDER_PATH_FETCH_BY_G_A = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
079                            JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
080                            FINDER_CLASS_NAME_ENTITY, "fetchByG_A",
081                            new String[] { Long.class.getName(), String.class.getName() });
082            public static final FinderPath FINDER_PATH_COUNT_BY_G_A = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
083                            JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
084                            FINDER_CLASS_NAME_LIST, "countByG_A",
085                            new String[] { Long.class.getName(), String.class.getName() });
086            public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
087                            JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
088                            FINDER_CLASS_NAME_LIST, "findAll", new String[0]);
089            public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
090                            JournalArticleResourceModelImpl.FINDER_CACHE_ENABLED,
091                            FINDER_CLASS_NAME_LIST, "countAll", new String[0]);
092    
093            public void cacheResult(JournalArticleResource journalArticleResource) {
094                    EntityCacheUtil.putResult(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
095                            JournalArticleResourceImpl.class,
096                            journalArticleResource.getPrimaryKey(), journalArticleResource);
097    
098                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A,
099                            new Object[] {
100                                    new Long(journalArticleResource.getGroupId()),
101                                    
102                            journalArticleResource.getArticleId()
103                            }, journalArticleResource);
104            }
105    
106            public void cacheResult(
107                    List<JournalArticleResource> journalArticleResources) {
108                    for (JournalArticleResource journalArticleResource : journalArticleResources) {
109                            if (EntityCacheUtil.getResult(
110                                                    JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
111                                                    JournalArticleResourceImpl.class,
112                                                    journalArticleResource.getPrimaryKey(), this) == null) {
113                                    cacheResult(journalArticleResource);
114                            }
115                    }
116            }
117    
118            public void clearCache() {
119                    CacheRegistryUtil.clear(JournalArticleResourceImpl.class.getName());
120                    EntityCacheUtil.clearCache(JournalArticleResourceImpl.class.getName());
121                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
122                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
123            }
124    
125            public void clearCache(JournalArticleResource journalArticleResource) {
126                    EntityCacheUtil.removeResult(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
127                            JournalArticleResourceImpl.class,
128                            journalArticleResource.getPrimaryKey());
129    
130                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_A,
131                            new Object[] {
132                                    new Long(journalArticleResource.getGroupId()),
133                                    
134                            journalArticleResource.getArticleId()
135                            });
136            }
137    
138            public JournalArticleResource create(long resourcePrimKey) {
139                    JournalArticleResource journalArticleResource = new JournalArticleResourceImpl();
140    
141                    journalArticleResource.setNew(true);
142                    journalArticleResource.setPrimaryKey(resourcePrimKey);
143    
144                    return journalArticleResource;
145            }
146    
147            public JournalArticleResource remove(Serializable primaryKey)
148                    throws NoSuchModelException, SystemException {
149                    return remove(((Long)primaryKey).longValue());
150            }
151    
152            public JournalArticleResource remove(long resourcePrimKey)
153                    throws NoSuchArticleResourceException, SystemException {
154                    Session session = null;
155    
156                    try {
157                            session = openSession();
158    
159                            JournalArticleResource journalArticleResource = (JournalArticleResource)session.get(JournalArticleResourceImpl.class,
160                                            new Long(resourcePrimKey));
161    
162                            if (journalArticleResource == null) {
163                                    if (_log.isWarnEnabled()) {
164                                            _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
165                                                    resourcePrimKey);
166                                    }
167    
168                                    throw new NoSuchArticleResourceException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
169                                            resourcePrimKey);
170                            }
171    
172                            return remove(journalArticleResource);
173                    }
174                    catch (NoSuchArticleResourceException nsee) {
175                            throw nsee;
176                    }
177                    catch (Exception e) {
178                            throw processException(e);
179                    }
180                    finally {
181                            closeSession(session);
182                    }
183            }
184    
185            protected JournalArticleResource removeImpl(
186                    JournalArticleResource journalArticleResource)
187                    throws SystemException {
188                    journalArticleResource = toUnwrappedModel(journalArticleResource);
189    
190                    Session session = null;
191    
192                    try {
193                            session = openSession();
194    
195                            if (journalArticleResource.isCachedModel() ||
196                                            BatchSessionUtil.isEnabled()) {
197                                    Object staleObject = session.get(JournalArticleResourceImpl.class,
198                                                    journalArticleResource.getPrimaryKeyObj());
199    
200                                    if (staleObject != null) {
201                                            session.evict(staleObject);
202                                    }
203                            }
204    
205                            session.delete(journalArticleResource);
206    
207                            session.flush();
208                    }
209                    catch (Exception e) {
210                            throw processException(e);
211                    }
212                    finally {
213                            closeSession(session);
214                    }
215    
216                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
217    
218                    JournalArticleResourceModelImpl journalArticleResourceModelImpl = (JournalArticleResourceModelImpl)journalArticleResource;
219    
220                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_A,
221                            new Object[] {
222                                    new Long(journalArticleResourceModelImpl.getOriginalGroupId()),
223                                    
224                            journalArticleResourceModelImpl.getOriginalArticleId()
225                            });
226    
227                    EntityCacheUtil.removeResult(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
228                            JournalArticleResourceImpl.class,
229                            journalArticleResource.getPrimaryKey());
230    
231                    return journalArticleResource;
232            }
233    
234            public JournalArticleResource updateImpl(
235                    com.liferay.portlet.journal.model.JournalArticleResource journalArticleResource,
236                    boolean merge) throws SystemException {
237                    journalArticleResource = toUnwrappedModel(journalArticleResource);
238    
239                    boolean isNew = journalArticleResource.isNew();
240    
241                    JournalArticleResourceModelImpl journalArticleResourceModelImpl = (JournalArticleResourceModelImpl)journalArticleResource;
242    
243                    Session session = null;
244    
245                    try {
246                            session = openSession();
247    
248                            BatchSessionUtil.update(session, journalArticleResource, merge);
249    
250                            journalArticleResource.setNew(false);
251                    }
252                    catch (Exception e) {
253                            throw processException(e);
254                    }
255                    finally {
256                            closeSession(session);
257                    }
258    
259                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
260    
261                    EntityCacheUtil.putResult(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
262                            JournalArticleResourceImpl.class,
263                            journalArticleResource.getPrimaryKey(), journalArticleResource);
264    
265                    if (!isNew &&
266                                    ((journalArticleResource.getGroupId() != journalArticleResourceModelImpl.getOriginalGroupId()) ||
267                                    !Validator.equals(journalArticleResource.getArticleId(),
268                                            journalArticleResourceModelImpl.getOriginalArticleId()))) {
269                            FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_A,
270                                    new Object[] {
271                                            new Long(journalArticleResourceModelImpl.getOriginalGroupId()),
272                                            
273                                    journalArticleResourceModelImpl.getOriginalArticleId()
274                                    });
275                    }
276    
277                    if (isNew ||
278                                    ((journalArticleResource.getGroupId() != journalArticleResourceModelImpl.getOriginalGroupId()) ||
279                                    !Validator.equals(journalArticleResource.getArticleId(),
280                                            journalArticleResourceModelImpl.getOriginalArticleId()))) {
281                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A,
282                                    new Object[] {
283                                            new Long(journalArticleResource.getGroupId()),
284                                            
285                                    journalArticleResource.getArticleId()
286                                    }, journalArticleResource);
287                    }
288    
289                    return journalArticleResource;
290            }
291    
292            protected JournalArticleResource toUnwrappedModel(
293                    JournalArticleResource journalArticleResource) {
294                    if (journalArticleResource instanceof JournalArticleResourceImpl) {
295                            return journalArticleResource;
296                    }
297    
298                    JournalArticleResourceImpl journalArticleResourceImpl = new JournalArticleResourceImpl();
299    
300                    journalArticleResourceImpl.setNew(journalArticleResource.isNew());
301                    journalArticleResourceImpl.setPrimaryKey(journalArticleResource.getPrimaryKey());
302    
303                    journalArticleResourceImpl.setResourcePrimKey(journalArticleResource.getResourcePrimKey());
304                    journalArticleResourceImpl.setGroupId(journalArticleResource.getGroupId());
305                    journalArticleResourceImpl.setArticleId(journalArticleResource.getArticleId());
306    
307                    return journalArticleResourceImpl;
308            }
309    
310            public JournalArticleResource findByPrimaryKey(Serializable primaryKey)
311                    throws NoSuchModelException, SystemException {
312                    return findByPrimaryKey(((Long)primaryKey).longValue());
313            }
314    
315            public JournalArticleResource findByPrimaryKey(long resourcePrimKey)
316                    throws NoSuchArticleResourceException, SystemException {
317                    JournalArticleResource journalArticleResource = fetchByPrimaryKey(resourcePrimKey);
318    
319                    if (journalArticleResource == null) {
320                            if (_log.isWarnEnabled()) {
321                                    _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + resourcePrimKey);
322                            }
323    
324                            throw new NoSuchArticleResourceException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
325                                    resourcePrimKey);
326                    }
327    
328                    return journalArticleResource;
329            }
330    
331            public JournalArticleResource fetchByPrimaryKey(Serializable primaryKey)
332                    throws SystemException {
333                    return fetchByPrimaryKey(((Long)primaryKey).longValue());
334            }
335    
336            public JournalArticleResource fetchByPrimaryKey(long resourcePrimKey)
337                    throws SystemException {
338                    JournalArticleResource journalArticleResource = (JournalArticleResource)EntityCacheUtil.getResult(JournalArticleResourceModelImpl.ENTITY_CACHE_ENABLED,
339                                    JournalArticleResourceImpl.class, resourcePrimKey, this);
340    
341                    if (journalArticleResource == null) {
342                            Session session = null;
343    
344                            try {
345                                    session = openSession();
346    
347                                    journalArticleResource = (JournalArticleResource)session.get(JournalArticleResourceImpl.class,
348                                                    new Long(resourcePrimKey));
349                            }
350                            catch (Exception e) {
351                                    throw processException(e);
352                            }
353                            finally {
354                                    if (journalArticleResource != null) {
355                                            cacheResult(journalArticleResource);
356                                    }
357    
358                                    closeSession(session);
359                            }
360                    }
361    
362                    return journalArticleResource;
363            }
364    
365            public List<JournalArticleResource> findByGroupId(long groupId)
366                    throws SystemException {
367                    return findByGroupId(groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
368            }
369    
370            public List<JournalArticleResource> findByGroupId(long groupId, int start,
371                    int end) throws SystemException {
372                    return findByGroupId(groupId, start, end, null);
373            }
374    
375            public List<JournalArticleResource> findByGroupId(long groupId, int start,
376                    int end, OrderByComparator orderByComparator) throws SystemException {
377                    Object[] finderArgs = new Object[] {
378                                    groupId,
379                                    
380                                    String.valueOf(start), String.valueOf(end),
381                                    String.valueOf(orderByComparator)
382                            };
383    
384                    List<JournalArticleResource> list = (List<JournalArticleResource>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_GROUPID,
385                                    finderArgs, this);
386    
387                    if (list == null) {
388                            Session session = null;
389    
390                            try {
391                                    session = openSession();
392    
393                                    StringBundler query = null;
394    
395                                    if (orderByComparator != null) {
396                                            query = new StringBundler(3 +
397                                                            (orderByComparator.getOrderByFields().length * 3));
398                                    }
399                                    else {
400                                            query = new StringBundler(2);
401                                    }
402    
403                                    query.append(_SQL_SELECT_JOURNALARTICLERESOURCE_WHERE);
404    
405                                    query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
406    
407                                    if (orderByComparator != null) {
408                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
409                                                    orderByComparator);
410                                    }
411    
412                                    String sql = query.toString();
413    
414                                    Query q = session.createQuery(sql);
415    
416                                    QueryPos qPos = QueryPos.getInstance(q);
417    
418                                    qPos.add(groupId);
419    
420                                    list = (List<JournalArticleResource>)QueryUtil.list(q,
421                                                    getDialect(), start, end);
422                            }
423                            catch (Exception e) {
424                                    throw processException(e);
425                            }
426                            finally {
427                                    if (list == null) {
428                                            list = new ArrayList<JournalArticleResource>();
429                                    }
430    
431                                    cacheResult(list);
432    
433                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_GROUPID,
434                                            finderArgs, list);
435    
436                                    closeSession(session);
437                            }
438                    }
439    
440                    return list;
441            }
442    
443            public JournalArticleResource findByGroupId_First(long groupId,
444                    OrderByComparator orderByComparator)
445                    throws NoSuchArticleResourceException, SystemException {
446                    List<JournalArticleResource> list = findByGroupId(groupId, 0, 1,
447                                    orderByComparator);
448    
449                    if (list.isEmpty()) {
450                            StringBundler msg = new StringBundler(4);
451    
452                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
453    
454                            msg.append("groupId=");
455                            msg.append(groupId);
456    
457                            msg.append(StringPool.CLOSE_CURLY_BRACE);
458    
459                            throw new NoSuchArticleResourceException(msg.toString());
460                    }
461                    else {
462                            return list.get(0);
463                    }
464            }
465    
466            public JournalArticleResource findByGroupId_Last(long groupId,
467                    OrderByComparator orderByComparator)
468                    throws NoSuchArticleResourceException, SystemException {
469                    int count = countByGroupId(groupId);
470    
471                    List<JournalArticleResource> list = findByGroupId(groupId, count - 1,
472                                    count, orderByComparator);
473    
474                    if (list.isEmpty()) {
475                            StringBundler msg = new StringBundler(4);
476    
477                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
478    
479                            msg.append("groupId=");
480                            msg.append(groupId);
481    
482                            msg.append(StringPool.CLOSE_CURLY_BRACE);
483    
484                            throw new NoSuchArticleResourceException(msg.toString());
485                    }
486                    else {
487                            return list.get(0);
488                    }
489            }
490    
491            public JournalArticleResource[] findByGroupId_PrevAndNext(
492                    long resourcePrimKey, long groupId, OrderByComparator orderByComparator)
493                    throws NoSuchArticleResourceException, SystemException {
494                    JournalArticleResource journalArticleResource = findByPrimaryKey(resourcePrimKey);
495    
496                    Session session = null;
497    
498                    try {
499                            session = openSession();
500    
501                            JournalArticleResource[] array = new JournalArticleResourceImpl[3];
502    
503                            array[0] = getByGroupId_PrevAndNext(session,
504                                            journalArticleResource, groupId, orderByComparator, true);
505    
506                            array[1] = journalArticleResource;
507    
508                            array[2] = getByGroupId_PrevAndNext(session,
509                                            journalArticleResource, groupId, orderByComparator, false);
510    
511                            return array;
512                    }
513                    catch (Exception e) {
514                            throw processException(e);
515                    }
516                    finally {
517                            closeSession(session);
518                    }
519            }
520    
521            protected JournalArticleResource getByGroupId_PrevAndNext(Session session,
522                    JournalArticleResource journalArticleResource, long groupId,
523                    OrderByComparator orderByComparator, boolean previous) {
524                    StringBundler query = null;
525    
526                    if (orderByComparator != null) {
527                            query = new StringBundler(6 +
528                                            (orderByComparator.getOrderByFields().length * 6));
529                    }
530                    else {
531                            query = new StringBundler(3);
532                    }
533    
534                    query.append(_SQL_SELECT_JOURNALARTICLERESOURCE_WHERE);
535    
536                    query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
537    
538                    if (orderByComparator != null) {
539                            String[] orderByFields = orderByComparator.getOrderByFields();
540    
541                            if (orderByFields.length > 0) {
542                                    query.append(WHERE_AND);
543                            }
544    
545                            for (int i = 0; i < orderByFields.length; i++) {
546                                    query.append(_ORDER_BY_ENTITY_ALIAS);
547                                    query.append(orderByFields[i]);
548    
549                                    if ((i + 1) < orderByFields.length) {
550                                            if (orderByComparator.isAscending() ^ previous) {
551                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
552                                            }
553                                            else {
554                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
555                                            }
556                                    }
557                                    else {
558                                            if (orderByComparator.isAscending() ^ previous) {
559                                                    query.append(WHERE_GREATER_THAN);
560                                            }
561                                            else {
562                                                    query.append(WHERE_LESSER_THAN);
563                                            }
564                                    }
565                            }
566    
567                            query.append(ORDER_BY_CLAUSE);
568    
569                            for (int i = 0; i < orderByFields.length; i++) {
570                                    query.append(_ORDER_BY_ENTITY_ALIAS);
571                                    query.append(orderByFields[i]);
572    
573                                    if ((i + 1) < orderByFields.length) {
574                                            if (orderByComparator.isAscending() ^ previous) {
575                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
576                                            }
577                                            else {
578                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
579                                            }
580                                    }
581                                    else {
582                                            if (orderByComparator.isAscending() ^ previous) {
583                                                    query.append(ORDER_BY_ASC);
584                                            }
585                                            else {
586                                                    query.append(ORDER_BY_DESC);
587                                            }
588                                    }
589                            }
590                    }
591    
592                    String sql = query.toString();
593    
594                    Query q = session.createQuery(sql);
595    
596                    q.setFirstResult(0);
597                    q.setMaxResults(2);
598    
599                    QueryPos qPos = QueryPos.getInstance(q);
600    
601                    qPos.add(groupId);
602    
603                    if (orderByComparator != null) {
604                            Object[] values = orderByComparator.getOrderByValues(journalArticleResource);
605    
606                            for (Object value : values) {
607                                    qPos.add(value);
608                            }
609                    }
610    
611                    List<JournalArticleResource> list = q.list();
612    
613                    if (list.size() == 2) {
614                            return list.get(1);
615                    }
616                    else {
617                            return null;
618                    }
619            }
620    
621            public JournalArticleResource findByG_A(long groupId, String articleId)
622                    throws NoSuchArticleResourceException, SystemException {
623                    JournalArticleResource journalArticleResource = fetchByG_A(groupId,
624                                    articleId);
625    
626                    if (journalArticleResource == null) {
627                            StringBundler msg = new StringBundler(6);
628    
629                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
630    
631                            msg.append("groupId=");
632                            msg.append(groupId);
633    
634                            msg.append(", articleId=");
635                            msg.append(articleId);
636    
637                            msg.append(StringPool.CLOSE_CURLY_BRACE);
638    
639                            if (_log.isWarnEnabled()) {
640                                    _log.warn(msg.toString());
641                            }
642    
643                            throw new NoSuchArticleResourceException(msg.toString());
644                    }
645    
646                    return journalArticleResource;
647            }
648    
649            public JournalArticleResource fetchByG_A(long groupId, String articleId)
650                    throws SystemException {
651                    return fetchByG_A(groupId, articleId, true);
652            }
653    
654            public JournalArticleResource fetchByG_A(long groupId, String articleId,
655                    boolean retrieveFromCache) throws SystemException {
656                    Object[] finderArgs = new Object[] { groupId, articleId };
657    
658                    Object result = null;
659    
660                    if (retrieveFromCache) {
661                            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_G_A,
662                                            finderArgs, this);
663                    }
664    
665                    if (result == null) {
666                            Session session = null;
667    
668                            try {
669                                    session = openSession();
670    
671                                    StringBundler query = new StringBundler(3);
672    
673                                    query.append(_SQL_SELECT_JOURNALARTICLERESOURCE_WHERE);
674    
675                                    query.append(_FINDER_COLUMN_G_A_GROUPID_2);
676    
677                                    if (articleId == null) {
678                                            query.append(_FINDER_COLUMN_G_A_ARTICLEID_1);
679                                    }
680                                    else {
681                                            if (articleId.equals(StringPool.BLANK)) {
682                                                    query.append(_FINDER_COLUMN_G_A_ARTICLEID_3);
683                                            }
684                                            else {
685                                                    query.append(_FINDER_COLUMN_G_A_ARTICLEID_2);
686                                            }
687                                    }
688    
689                                    String sql = query.toString();
690    
691                                    Query q = session.createQuery(sql);
692    
693                                    QueryPos qPos = QueryPos.getInstance(q);
694    
695                                    qPos.add(groupId);
696    
697                                    if (articleId != null) {
698                                            qPos.add(articleId);
699                                    }
700    
701                                    List<JournalArticleResource> list = q.list();
702    
703                                    result = list;
704    
705                                    JournalArticleResource journalArticleResource = null;
706    
707                                    if (list.isEmpty()) {
708                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A,
709                                                    finderArgs, list);
710                                    }
711                                    else {
712                                            journalArticleResource = list.get(0);
713    
714                                            cacheResult(journalArticleResource);
715    
716                                            if ((journalArticleResource.getGroupId() != groupId) ||
717                                                            (journalArticleResource.getArticleId() == null) ||
718                                                            !journalArticleResource.getArticleId()
719                                                                                                               .equals(articleId)) {
720                                                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A,
721                                                            finderArgs, journalArticleResource);
722                                            }
723                                    }
724    
725                                    return journalArticleResource;
726                            }
727                            catch (Exception e) {
728                                    throw processException(e);
729                            }
730                            finally {
731                                    if (result == null) {
732                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_A,
733                                                    finderArgs, new ArrayList<JournalArticleResource>());
734                                    }
735    
736                                    closeSession(session);
737                            }
738                    }
739                    else {
740                            if (result instanceof List<?>) {
741                                    return null;
742                            }
743                            else {
744                                    return (JournalArticleResource)result;
745                            }
746                    }
747            }
748    
749            public List<JournalArticleResource> findAll() throws SystemException {
750                    return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
751            }
752    
753            public List<JournalArticleResource> findAll(int start, int end)
754                    throws SystemException {
755                    return findAll(start, end, null);
756            }
757    
758            public List<JournalArticleResource> findAll(int start, int end,
759                    OrderByComparator orderByComparator) throws SystemException {
760                    Object[] finderArgs = new Object[] {
761                                    String.valueOf(start), String.valueOf(end),
762                                    String.valueOf(orderByComparator)
763                            };
764    
765                    List<JournalArticleResource> list = (List<JournalArticleResource>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
766                                    finderArgs, this);
767    
768                    if (list == null) {
769                            Session session = null;
770    
771                            try {
772                                    session = openSession();
773    
774                                    StringBundler query = null;
775                                    String sql = null;
776    
777                                    if (orderByComparator != null) {
778                                            query = new StringBundler(2 +
779                                                            (orderByComparator.getOrderByFields().length * 3));
780    
781                                            query.append(_SQL_SELECT_JOURNALARTICLERESOURCE);
782    
783                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
784                                                    orderByComparator);
785    
786                                            sql = query.toString();
787                                    }
788                                    else {
789                                            sql = _SQL_SELECT_JOURNALARTICLERESOURCE;
790                                    }
791    
792                                    Query q = session.createQuery(sql);
793    
794                                    if (orderByComparator == null) {
795                                            list = (List<JournalArticleResource>)QueryUtil.list(q,
796                                                            getDialect(), start, end, false);
797    
798                                            Collections.sort(list);
799                                    }
800                                    else {
801                                            list = (List<JournalArticleResource>)QueryUtil.list(q,
802                                                            getDialect(), start, end);
803                                    }
804                            }
805                            catch (Exception e) {
806                                    throw processException(e);
807                            }
808                            finally {
809                                    if (list == null) {
810                                            list = new ArrayList<JournalArticleResource>();
811                                    }
812    
813                                    cacheResult(list);
814    
815                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
816    
817                                    closeSession(session);
818                            }
819                    }
820    
821                    return list;
822            }
823    
824            public void removeByGroupId(long groupId) throws SystemException {
825                    for (JournalArticleResource journalArticleResource : findByGroupId(
826                                    groupId)) {
827                            remove(journalArticleResource);
828                    }
829            }
830    
831            public void removeByG_A(long groupId, String articleId)
832                    throws NoSuchArticleResourceException, SystemException {
833                    JournalArticleResource journalArticleResource = findByG_A(groupId,
834                                    articleId);
835    
836                    remove(journalArticleResource);
837            }
838    
839            public void removeAll() throws SystemException {
840                    for (JournalArticleResource journalArticleResource : findAll()) {
841                            remove(journalArticleResource);
842                    }
843            }
844    
845            public int countByGroupId(long groupId) throws SystemException {
846                    Object[] finderArgs = new Object[] { groupId };
847    
848                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_GROUPID,
849                                    finderArgs, this);
850    
851                    if (count == null) {
852                            Session session = null;
853    
854                            try {
855                                    session = openSession();
856    
857                                    StringBundler query = new StringBundler(2);
858    
859                                    query.append(_SQL_COUNT_JOURNALARTICLERESOURCE_WHERE);
860    
861                                    query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
862    
863                                    String sql = query.toString();
864    
865                                    Query q = session.createQuery(sql);
866    
867                                    QueryPos qPos = QueryPos.getInstance(q);
868    
869                                    qPos.add(groupId);
870    
871                                    count = (Long)q.uniqueResult();
872                            }
873                            catch (Exception e) {
874                                    throw processException(e);
875                            }
876                            finally {
877                                    if (count == null) {
878                                            count = Long.valueOf(0);
879                                    }
880    
881                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_GROUPID,
882                                            finderArgs, count);
883    
884                                    closeSession(session);
885                            }
886                    }
887    
888                    return count.intValue();
889            }
890    
891            public int countByG_A(long groupId, String articleId)
892                    throws SystemException {
893                    Object[] finderArgs = new Object[] { groupId, articleId };
894    
895                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_A,
896                                    finderArgs, this);
897    
898                    if (count == null) {
899                            Session session = null;
900    
901                            try {
902                                    session = openSession();
903    
904                                    StringBundler query = new StringBundler(3);
905    
906                                    query.append(_SQL_COUNT_JOURNALARTICLERESOURCE_WHERE);
907    
908                                    query.append(_FINDER_COLUMN_G_A_GROUPID_2);
909    
910                                    if (articleId == null) {
911                                            query.append(_FINDER_COLUMN_G_A_ARTICLEID_1);
912                                    }
913                                    else {
914                                            if (articleId.equals(StringPool.BLANK)) {
915                                                    query.append(_FINDER_COLUMN_G_A_ARTICLEID_3);
916                                            }
917                                            else {
918                                                    query.append(_FINDER_COLUMN_G_A_ARTICLEID_2);
919                                            }
920                                    }
921    
922                                    String sql = query.toString();
923    
924                                    Query q = session.createQuery(sql);
925    
926                                    QueryPos qPos = QueryPos.getInstance(q);
927    
928                                    qPos.add(groupId);
929    
930                                    if (articleId != null) {
931                                            qPos.add(articleId);
932                                    }
933    
934                                    count = (Long)q.uniqueResult();
935                            }
936                            catch (Exception e) {
937                                    throw processException(e);
938                            }
939                            finally {
940                                    if (count == null) {
941                                            count = Long.valueOf(0);
942                                    }
943    
944                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_A, finderArgs,
945                                            count);
946    
947                                    closeSession(session);
948                            }
949                    }
950    
951                    return count.intValue();
952            }
953    
954            public int countAll() throws SystemException {
955                    Object[] finderArgs = new Object[0];
956    
957                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
958                                    finderArgs, this);
959    
960                    if (count == null) {
961                            Session session = null;
962    
963                            try {
964                                    session = openSession();
965    
966                                    Query q = session.createQuery(_SQL_COUNT_JOURNALARTICLERESOURCE);
967    
968                                    count = (Long)q.uniqueResult();
969                            }
970                            catch (Exception e) {
971                                    throw processException(e);
972                            }
973                            finally {
974                                    if (count == null) {
975                                            count = Long.valueOf(0);
976                                    }
977    
978                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
979                                            count);
980    
981                                    closeSession(session);
982                            }
983                    }
984    
985                    return count.intValue();
986            }
987    
988            public void afterPropertiesSet() {
989                    String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
990                                            com.liferay.portal.util.PropsUtil.get(
991                                                    "value.object.listener.com.liferay.portlet.journal.model.JournalArticleResource")));
992    
993                    if (listenerClassNames.length > 0) {
994                            try {
995                                    List<ModelListener<JournalArticleResource>> listenersList = new ArrayList<ModelListener<JournalArticleResource>>();
996    
997                                    for (String listenerClassName : listenerClassNames) {
998                                            listenersList.add((ModelListener<JournalArticleResource>)InstanceFactory.newInstance(
999                                                            listenerClassName));
1000                                    }
1001    
1002                                    listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
1003                            }
1004                            catch (Exception e) {
1005                                    _log.error(e);
1006                            }
1007                    }
1008            }
1009    
1010            @BeanReference(type = JournalArticlePersistence.class)
1011            protected JournalArticlePersistence journalArticlePersistence;
1012            @BeanReference(type = JournalArticleImagePersistence.class)
1013            protected JournalArticleImagePersistence journalArticleImagePersistence;
1014            @BeanReference(type = JournalArticleResourcePersistence.class)
1015            protected JournalArticleResourcePersistence journalArticleResourcePersistence;
1016            @BeanReference(type = JournalContentSearchPersistence.class)
1017            protected JournalContentSearchPersistence journalContentSearchPersistence;
1018            @BeanReference(type = JournalFeedPersistence.class)
1019            protected JournalFeedPersistence journalFeedPersistence;
1020            @BeanReference(type = JournalStructurePersistence.class)
1021            protected JournalStructurePersistence journalStructurePersistence;
1022            @BeanReference(type = JournalTemplatePersistence.class)
1023            protected JournalTemplatePersistence journalTemplatePersistence;
1024            @BeanReference(type = ResourcePersistence.class)
1025            protected ResourcePersistence resourcePersistence;
1026            @BeanReference(type = UserPersistence.class)
1027            protected UserPersistence userPersistence;
1028            private static final String _SQL_SELECT_JOURNALARTICLERESOURCE = "SELECT journalArticleResource FROM JournalArticleResource journalArticleResource";
1029            private static final String _SQL_SELECT_JOURNALARTICLERESOURCE_WHERE = "SELECT journalArticleResource FROM JournalArticleResource journalArticleResource WHERE ";
1030            private static final String _SQL_COUNT_JOURNALARTICLERESOURCE = "SELECT COUNT(journalArticleResource) FROM JournalArticleResource journalArticleResource";
1031            private static final String _SQL_COUNT_JOURNALARTICLERESOURCE_WHERE = "SELECT COUNT(journalArticleResource) FROM JournalArticleResource journalArticleResource WHERE ";
1032            private static final String _FINDER_COLUMN_GROUPID_GROUPID_2 = "journalArticleResource.groupId = ?";
1033            private static final String _FINDER_COLUMN_G_A_GROUPID_2 = "journalArticleResource.groupId = ? AND ";
1034            private static final String _FINDER_COLUMN_G_A_ARTICLEID_1 = "journalArticleResource.articleId IS NULL";
1035            private static final String _FINDER_COLUMN_G_A_ARTICLEID_2 = "journalArticleResource.articleId = ?";
1036            private static final String _FINDER_COLUMN_G_A_ARTICLEID_3 = "(journalArticleResource.articleId IS NULL OR journalArticleResource.articleId = ?)";
1037            private static final String _ORDER_BY_ENTITY_ALIAS = "journalArticleResource.";
1038            private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No JournalArticleResource exists with the primary key ";
1039            private static final String _NO_SUCH_ENTITY_WITH_KEY = "No JournalArticleResource exists with the key {";
1040            private static Log _log = LogFactoryUtil.getLog(JournalArticleResourcePersistenceImpl.class);
1041    }