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.blogs.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.SQLQuery;
027    import com.liferay.portal.kernel.dao.orm.Session;
028    import com.liferay.portal.kernel.exception.SystemException;
029    import com.liferay.portal.kernel.log.Log;
030    import com.liferay.portal.kernel.log.LogFactoryUtil;
031    import com.liferay.portal.kernel.sanitizer.Sanitizer;
032    import com.liferay.portal.kernel.sanitizer.SanitizerException;
033    import com.liferay.portal.kernel.sanitizer.SanitizerUtil;
034    import com.liferay.portal.kernel.util.CalendarUtil;
035    import com.liferay.portal.kernel.util.ContentTypes;
036    import com.liferay.portal.kernel.util.GetterUtil;
037    import com.liferay.portal.kernel.util.InstanceFactory;
038    import com.liferay.portal.kernel.util.OrderByComparator;
039    import com.liferay.portal.kernel.util.StringBundler;
040    import com.liferay.portal.kernel.util.StringPool;
041    import com.liferay.portal.kernel.util.StringUtil;
042    import com.liferay.portal.kernel.util.Validator;
043    import com.liferay.portal.kernel.uuid.PortalUUIDUtil;
044    import com.liferay.portal.model.ModelListener;
045    import com.liferay.portal.security.auth.PrincipalThreadLocal;
046    import com.liferay.portal.security.permission.InlineSQLHelperUtil;
047    import com.liferay.portal.service.persistence.BatchSessionUtil;
048    import com.liferay.portal.service.persistence.CompanyPersistence;
049    import com.liferay.portal.service.persistence.GroupPersistence;
050    import com.liferay.portal.service.persistence.OrganizationPersistence;
051    import com.liferay.portal.service.persistence.PortletPreferencesPersistence;
052    import com.liferay.portal.service.persistence.ResourcePersistence;
053    import com.liferay.portal.service.persistence.UserPersistence;
054    import com.liferay.portal.service.persistence.WorkflowInstanceLinkPersistence;
055    import com.liferay.portal.service.persistence.impl.BasePersistenceImpl;
056    
057    import com.liferay.portlet.asset.service.persistence.AssetEntryPersistence;
058    import com.liferay.portlet.asset.service.persistence.AssetTagPersistence;
059    import com.liferay.portlet.blogs.NoSuchEntryException;
060    import com.liferay.portlet.blogs.model.BlogsEntry;
061    import com.liferay.portlet.blogs.model.impl.BlogsEntryImpl;
062    import com.liferay.portlet.blogs.model.impl.BlogsEntryModelImpl;
063    import com.liferay.portlet.expando.service.persistence.ExpandoValuePersistence;
064    import com.liferay.portlet.messageboards.service.persistence.MBMessagePersistence;
065    import com.liferay.portlet.ratings.service.persistence.RatingsStatsPersistence;
066    import com.liferay.portlet.social.service.persistence.SocialActivityPersistence;
067    import com.liferay.portlet.social.service.persistence.SocialEquityLogPersistence;
068    
069    import java.io.Serializable;
070    
071    import java.util.ArrayList;
072    import java.util.Collections;
073    import java.util.Date;
074    import java.util.List;
075    
076    /**
077     * @author    Brian Wing Shun Chan
078     * @see       BlogsEntryPersistence
079     * @see       BlogsEntryUtil
080     * @generated
081     */
082    public class BlogsEntryPersistenceImpl extends BasePersistenceImpl<BlogsEntry>
083            implements BlogsEntryPersistence {
084            public static final String FINDER_CLASS_NAME_ENTITY = BlogsEntryImpl.class.getName();
085            public static final String FINDER_CLASS_NAME_LIST = FINDER_CLASS_NAME_ENTITY +
086                    ".List";
087            public static final FinderPath FINDER_PATH_FIND_BY_UUID = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
088                            BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
089                            "findByUuid",
090                            new String[] {
091                                    String.class.getName(),
092                                    
093                            "java.lang.Integer", "java.lang.Integer",
094                                    "com.liferay.portal.kernel.util.OrderByComparator"
095                            });
096            public static final FinderPath FINDER_PATH_COUNT_BY_UUID = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
097                            BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
098                            "countByUuid", new String[] { String.class.getName() });
099            public static final FinderPath FINDER_PATH_FETCH_BY_UUID_G = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
100                            BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_ENTITY,
101                            "fetchByUUID_G",
102                            new String[] { String.class.getName(), Long.class.getName() });
103            public static final FinderPath FINDER_PATH_COUNT_BY_UUID_G = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
104                            BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
105                            "countByUUID_G",
106                            new String[] { String.class.getName(), Long.class.getName() });
107            public static final FinderPath FINDER_PATH_FIND_BY_GROUPID = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
108                            BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
109                            "findByGroupId",
110                            new String[] {
111                                    Long.class.getName(),
112                                    
113                            "java.lang.Integer", "java.lang.Integer",
114                                    "com.liferay.portal.kernel.util.OrderByComparator"
115                            });
116            public static final FinderPath FINDER_PATH_COUNT_BY_GROUPID = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
117                            BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
118                            "countByGroupId", new String[] { Long.class.getName() });
119            public static final FinderPath FINDER_PATH_FIND_BY_COMPANYID = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
120                            BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
121                            "findByCompanyId",
122                            new String[] {
123                                    Long.class.getName(),
124                                    
125                            "java.lang.Integer", "java.lang.Integer",
126                                    "com.liferay.portal.kernel.util.OrderByComparator"
127                            });
128            public static final FinderPath FINDER_PATH_COUNT_BY_COMPANYID = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
129                            BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
130                            "countByCompanyId", new String[] { Long.class.getName() });
131            public static final FinderPath FINDER_PATH_FIND_BY_C_U = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
132                            BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
133                            "findByC_U",
134                            new String[] {
135                                    Long.class.getName(), Long.class.getName(),
136                                    
137                            "java.lang.Integer", "java.lang.Integer",
138                                    "com.liferay.portal.kernel.util.OrderByComparator"
139                            });
140            public static final FinderPath FINDER_PATH_COUNT_BY_C_U = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
141                            BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
142                            "countByC_U",
143                            new String[] { Long.class.getName(), Long.class.getName() });
144            public static final FinderPath FINDER_PATH_FIND_BY_C_LTD = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
145                            BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
146                            "findByC_LtD",
147                            new String[] {
148                                    Long.class.getName(), Date.class.getName(),
149                                    
150                            "java.lang.Integer", "java.lang.Integer",
151                                    "com.liferay.portal.kernel.util.OrderByComparator"
152                            });
153            public static final FinderPath FINDER_PATH_COUNT_BY_C_LTD = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
154                            BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
155                            "countByC_LtD",
156                            new String[] { Long.class.getName(), Date.class.getName() });
157            public static final FinderPath FINDER_PATH_FIND_BY_C_S = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
158                            BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
159                            "findByC_S",
160                            new String[] {
161                                    Long.class.getName(), Integer.class.getName(),
162                                    
163                            "java.lang.Integer", "java.lang.Integer",
164                                    "com.liferay.portal.kernel.util.OrderByComparator"
165                            });
166            public static final FinderPath FINDER_PATH_COUNT_BY_C_S = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
167                            BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
168                            "countByC_S",
169                            new String[] { Long.class.getName(), Integer.class.getName() });
170            public static final FinderPath FINDER_PATH_FETCH_BY_G_UT = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
171                            BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_ENTITY,
172                            "fetchByG_UT",
173                            new String[] { Long.class.getName(), String.class.getName() });
174            public static final FinderPath FINDER_PATH_COUNT_BY_G_UT = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
175                            BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
176                            "countByG_UT",
177                            new String[] { Long.class.getName(), String.class.getName() });
178            public static final FinderPath FINDER_PATH_FIND_BY_G_LTD = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
179                            BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
180                            "findByG_LtD",
181                            new String[] {
182                                    Long.class.getName(), Date.class.getName(),
183                                    
184                            "java.lang.Integer", "java.lang.Integer",
185                                    "com.liferay.portal.kernel.util.OrderByComparator"
186                            });
187            public static final FinderPath FINDER_PATH_COUNT_BY_G_LTD = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
188                            BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
189                            "countByG_LtD",
190                            new String[] { Long.class.getName(), Date.class.getName() });
191            public static final FinderPath FINDER_PATH_FIND_BY_G_S = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
192                            BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
193                            "findByG_S",
194                            new String[] {
195                                    Long.class.getName(), Integer.class.getName(),
196                                    
197                            "java.lang.Integer", "java.lang.Integer",
198                                    "com.liferay.portal.kernel.util.OrderByComparator"
199                            });
200            public static final FinderPath FINDER_PATH_COUNT_BY_G_S = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
201                            BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
202                            "countByG_S",
203                            new String[] { Long.class.getName(), Integer.class.getName() });
204            public static final FinderPath FINDER_PATH_FIND_BY_C_U_S = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
205                            BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
206                            "findByC_U_S",
207                            new String[] {
208                                    Long.class.getName(), Long.class.getName(),
209                                    Integer.class.getName(),
210                                    
211                            "java.lang.Integer", "java.lang.Integer",
212                                    "com.liferay.portal.kernel.util.OrderByComparator"
213                            });
214            public static final FinderPath FINDER_PATH_COUNT_BY_C_U_S = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
215                            BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
216                            "countByC_U_S",
217                            new String[] {
218                                    Long.class.getName(), Long.class.getName(),
219                                    Integer.class.getName()
220                            });
221            public static final FinderPath FINDER_PATH_FIND_BY_C_LTD_S = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
222                            BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
223                            "findByC_LtD_S",
224                            new String[] {
225                                    Long.class.getName(), Date.class.getName(),
226                                    Integer.class.getName(),
227                                    
228                            "java.lang.Integer", "java.lang.Integer",
229                                    "com.liferay.portal.kernel.util.OrderByComparator"
230                            });
231            public static final FinderPath FINDER_PATH_COUNT_BY_C_LTD_S = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
232                            BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
233                            "countByC_LtD_S",
234                            new String[] {
235                                    Long.class.getName(), Date.class.getName(),
236                                    Integer.class.getName()
237                            });
238            public static final FinderPath FINDER_PATH_FIND_BY_G_U_LTD = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
239                            BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
240                            "findByG_U_LtD",
241                            new String[] {
242                                    Long.class.getName(), Long.class.getName(), Date.class.getName(),
243                                    
244                            "java.lang.Integer", "java.lang.Integer",
245                                    "com.liferay.portal.kernel.util.OrderByComparator"
246                            });
247            public static final FinderPath FINDER_PATH_COUNT_BY_G_U_LTD = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
248                            BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
249                            "countByG_U_LtD",
250                            new String[] {
251                                    Long.class.getName(), Long.class.getName(), Date.class.getName()
252                            });
253            public static final FinderPath FINDER_PATH_FIND_BY_G_U_S = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
254                            BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
255                            "findByG_U_S",
256                            new String[] {
257                                    Long.class.getName(), Long.class.getName(),
258                                    Integer.class.getName(),
259                                    
260                            "java.lang.Integer", "java.lang.Integer",
261                                    "com.liferay.portal.kernel.util.OrderByComparator"
262                            });
263            public static final FinderPath FINDER_PATH_COUNT_BY_G_U_S = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
264                            BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
265                            "countByG_U_S",
266                            new String[] {
267                                    Long.class.getName(), Long.class.getName(),
268                                    Integer.class.getName()
269                            });
270            public static final FinderPath FINDER_PATH_FIND_BY_G_LTD_S = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
271                            BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
272                            "findByG_LtD_S",
273                            new String[] {
274                                    Long.class.getName(), Date.class.getName(),
275                                    Integer.class.getName(),
276                                    
277                            "java.lang.Integer", "java.lang.Integer",
278                                    "com.liferay.portal.kernel.util.OrderByComparator"
279                            });
280            public static final FinderPath FINDER_PATH_COUNT_BY_G_LTD_S = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
281                            BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
282                            "countByG_LtD_S",
283                            new String[] {
284                                    Long.class.getName(), Date.class.getName(),
285                                    Integer.class.getName()
286                            });
287            public static final FinderPath FINDER_PATH_FIND_BY_G_U_LTD_S = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
288                            BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
289                            "findByG_U_LtD_S",
290                            new String[] {
291                                    Long.class.getName(), Long.class.getName(), Date.class.getName(),
292                                    Integer.class.getName(),
293                                    
294                            "java.lang.Integer", "java.lang.Integer",
295                                    "com.liferay.portal.kernel.util.OrderByComparator"
296                            });
297            public static final FinderPath FINDER_PATH_COUNT_BY_G_U_LTD_S = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
298                            BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
299                            "countByG_U_LtD_S",
300                            new String[] {
301                                    Long.class.getName(), Long.class.getName(), Date.class.getName(),
302                                    Integer.class.getName()
303                            });
304            public static final FinderPath FINDER_PATH_FIND_ALL = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
305                            BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
306                            "findAll", new String[0]);
307            public static final FinderPath FINDER_PATH_COUNT_ALL = new FinderPath(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
308                            BlogsEntryModelImpl.FINDER_CACHE_ENABLED, FINDER_CLASS_NAME_LIST,
309                            "countAll", new String[0]);
310    
311            public void cacheResult(BlogsEntry blogsEntry) {
312                    EntityCacheUtil.putResult(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
313                            BlogsEntryImpl.class, blogsEntry.getPrimaryKey(), blogsEntry);
314    
315                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
316                            new Object[] { blogsEntry.getUuid(), new Long(
317                                            blogsEntry.getGroupId()) }, blogsEntry);
318    
319                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_UT,
320                            new Object[] {
321                                    new Long(blogsEntry.getGroupId()),
322                                    
323                            blogsEntry.getUrlTitle()
324                            }, blogsEntry);
325            }
326    
327            public void cacheResult(List<BlogsEntry> blogsEntries) {
328                    for (BlogsEntry blogsEntry : blogsEntries) {
329                            if (EntityCacheUtil.getResult(
330                                                    BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
331                                                    BlogsEntryImpl.class, blogsEntry.getPrimaryKey(), this) == null) {
332                                    cacheResult(blogsEntry);
333                            }
334                    }
335            }
336    
337            public void clearCache() {
338                    CacheRegistryUtil.clear(BlogsEntryImpl.class.getName());
339                    EntityCacheUtil.clearCache(BlogsEntryImpl.class.getName());
340                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_ENTITY);
341                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
342            }
343    
344            public void clearCache(BlogsEntry blogsEntry) {
345                    EntityCacheUtil.removeResult(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
346                            BlogsEntryImpl.class, blogsEntry.getPrimaryKey());
347    
348                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
349                            new Object[] { blogsEntry.getUuid(), new Long(
350                                            blogsEntry.getGroupId()) });
351    
352                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_UT,
353                            new Object[] {
354                                    new Long(blogsEntry.getGroupId()),
355                                    
356                            blogsEntry.getUrlTitle()
357                            });
358            }
359    
360            public BlogsEntry create(long entryId) {
361                    BlogsEntry blogsEntry = new BlogsEntryImpl();
362    
363                    blogsEntry.setNew(true);
364                    blogsEntry.setPrimaryKey(entryId);
365    
366                    String uuid = PortalUUIDUtil.generate();
367    
368                    blogsEntry.setUuid(uuid);
369    
370                    return blogsEntry;
371            }
372    
373            public BlogsEntry remove(Serializable primaryKey)
374                    throws NoSuchModelException, SystemException {
375                    return remove(((Long)primaryKey).longValue());
376            }
377    
378            public BlogsEntry remove(long entryId)
379                    throws NoSuchEntryException, SystemException {
380                    Session session = null;
381    
382                    try {
383                            session = openSession();
384    
385                            BlogsEntry blogsEntry = (BlogsEntry)session.get(BlogsEntryImpl.class,
386                                            new Long(entryId));
387    
388                            if (blogsEntry == null) {
389                                    if (_log.isWarnEnabled()) {
390                                            _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + entryId);
391                                    }
392    
393                                    throw new NoSuchEntryException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
394                                            entryId);
395                            }
396    
397                            return remove(blogsEntry);
398                    }
399                    catch (NoSuchEntryException nsee) {
400                            throw nsee;
401                    }
402                    catch (Exception e) {
403                            throw processException(e);
404                    }
405                    finally {
406                            closeSession(session);
407                    }
408            }
409    
410            protected BlogsEntry removeImpl(BlogsEntry blogsEntry)
411                    throws SystemException {
412                    blogsEntry = toUnwrappedModel(blogsEntry);
413    
414                    Session session = null;
415    
416                    try {
417                            session = openSession();
418    
419                            if (blogsEntry.isCachedModel() || BatchSessionUtil.isEnabled()) {
420                                    Object staleObject = session.get(BlogsEntryImpl.class,
421                                                    blogsEntry.getPrimaryKeyObj());
422    
423                                    if (staleObject != null) {
424                                            session.evict(staleObject);
425                                    }
426                            }
427    
428                            session.delete(blogsEntry);
429    
430                            session.flush();
431                    }
432                    catch (Exception e) {
433                            throw processException(e);
434                    }
435                    finally {
436                            closeSession(session);
437                    }
438    
439                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
440    
441                    BlogsEntryModelImpl blogsEntryModelImpl = (BlogsEntryModelImpl)blogsEntry;
442    
443                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
444                            new Object[] {
445                                    blogsEntryModelImpl.getOriginalUuid(),
446                                    new Long(blogsEntryModelImpl.getOriginalGroupId())
447                            });
448    
449                    FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_UT,
450                            new Object[] {
451                                    new Long(blogsEntryModelImpl.getOriginalGroupId()),
452                                    
453                            blogsEntryModelImpl.getOriginalUrlTitle()
454                            });
455    
456                    EntityCacheUtil.removeResult(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
457                            BlogsEntryImpl.class, blogsEntry.getPrimaryKey());
458    
459                    return blogsEntry;
460            }
461    
462            public BlogsEntry updateImpl(
463                    com.liferay.portlet.blogs.model.BlogsEntry blogsEntry, boolean merge)
464                    throws SystemException {
465                    blogsEntry = toUnwrappedModel(blogsEntry);
466    
467                    boolean isNew = blogsEntry.isNew();
468    
469                    BlogsEntryModelImpl blogsEntryModelImpl = (BlogsEntryModelImpl)blogsEntry;
470    
471                    if (Validator.isNull(blogsEntry.getUuid())) {
472                            String uuid = PortalUUIDUtil.generate();
473    
474                            blogsEntry.setUuid(uuid);
475                    }
476    
477                    long userId = GetterUtil.getLong(PrincipalThreadLocal.getName());
478    
479                    if (userId > 0) {
480                            long companyId = blogsEntry.getCompanyId();
481    
482                            long groupId = blogsEntry.getGroupId();
483    
484                            long entryId = 0;
485    
486                            if (!isNew) {
487                                    entryId = blogsEntry.getPrimaryKey();
488                            }
489    
490                            try {
491                                    blogsEntry.setTitle(SanitizerUtil.sanitize(companyId, groupId,
492                                                    userId,
493                                                    com.liferay.portlet.blogs.model.BlogsEntry.class.getName(),
494                                                    entryId, ContentTypes.TEXT_PLAIN, Sanitizer.MODE_ALL,
495                                                    blogsEntry.getTitle(), null));
496    
497                                    blogsEntry.setContent(SanitizerUtil.sanitize(companyId,
498                                                    groupId, userId,
499                                                    com.liferay.portlet.blogs.model.BlogsEntry.class.getName(),
500                                                    entryId, ContentTypes.TEXT_HTML, Sanitizer.MODE_ALL,
501                                                    blogsEntry.getContent(), null));
502                            }
503                            catch (SanitizerException se) {
504                                    throw new SystemException(se);
505                            }
506                    }
507    
508                    Session session = null;
509    
510                    try {
511                            session = openSession();
512    
513                            BatchSessionUtil.update(session, blogsEntry, merge);
514    
515                            blogsEntry.setNew(false);
516                    }
517                    catch (Exception e) {
518                            throw processException(e);
519                    }
520                    finally {
521                            closeSession(session);
522                    }
523    
524                    FinderCacheUtil.clearCache(FINDER_CLASS_NAME_LIST);
525    
526                    EntityCacheUtil.putResult(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
527                            BlogsEntryImpl.class, blogsEntry.getPrimaryKey(), blogsEntry);
528    
529                    if (!isNew &&
530                                    (!Validator.equals(blogsEntry.getUuid(),
531                                            blogsEntryModelImpl.getOriginalUuid()) ||
532                                    (blogsEntry.getGroupId() != blogsEntryModelImpl.getOriginalGroupId()))) {
533                            FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_UUID_G,
534                                    new Object[] {
535                                            blogsEntryModelImpl.getOriginalUuid(),
536                                            new Long(blogsEntryModelImpl.getOriginalGroupId())
537                                    });
538                    }
539    
540                    if (isNew ||
541                                    (!Validator.equals(blogsEntry.getUuid(),
542                                            blogsEntryModelImpl.getOriginalUuid()) ||
543                                    (blogsEntry.getGroupId() != blogsEntryModelImpl.getOriginalGroupId()))) {
544                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
545                                    new Object[] {
546                                            blogsEntry.getUuid(), new Long(blogsEntry.getGroupId())
547                                    }, blogsEntry);
548                    }
549    
550                    if (!isNew &&
551                                    ((blogsEntry.getGroupId() != blogsEntryModelImpl.getOriginalGroupId()) ||
552                                    !Validator.equals(blogsEntry.getUrlTitle(),
553                                            blogsEntryModelImpl.getOriginalUrlTitle()))) {
554                            FinderCacheUtil.removeResult(FINDER_PATH_FETCH_BY_G_UT,
555                                    new Object[] {
556                                            new Long(blogsEntryModelImpl.getOriginalGroupId()),
557                                            
558                                    blogsEntryModelImpl.getOriginalUrlTitle()
559                                    });
560                    }
561    
562                    if (isNew ||
563                                    ((blogsEntry.getGroupId() != blogsEntryModelImpl.getOriginalGroupId()) ||
564                                    !Validator.equals(blogsEntry.getUrlTitle(),
565                                            blogsEntryModelImpl.getOriginalUrlTitle()))) {
566                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_UT,
567                                    new Object[] {
568                                            new Long(blogsEntry.getGroupId()),
569                                            
570                                    blogsEntry.getUrlTitle()
571                                    }, blogsEntry);
572                    }
573    
574                    return blogsEntry;
575            }
576    
577            protected BlogsEntry toUnwrappedModel(BlogsEntry blogsEntry) {
578                    if (blogsEntry instanceof BlogsEntryImpl) {
579                            return blogsEntry;
580                    }
581    
582                    BlogsEntryImpl blogsEntryImpl = new BlogsEntryImpl();
583    
584                    blogsEntryImpl.setNew(blogsEntry.isNew());
585                    blogsEntryImpl.setPrimaryKey(blogsEntry.getPrimaryKey());
586    
587                    blogsEntryImpl.setUuid(blogsEntry.getUuid());
588                    blogsEntryImpl.setEntryId(blogsEntry.getEntryId());
589                    blogsEntryImpl.setGroupId(blogsEntry.getGroupId());
590                    blogsEntryImpl.setCompanyId(blogsEntry.getCompanyId());
591                    blogsEntryImpl.setUserId(blogsEntry.getUserId());
592                    blogsEntryImpl.setUserName(blogsEntry.getUserName());
593                    blogsEntryImpl.setCreateDate(blogsEntry.getCreateDate());
594                    blogsEntryImpl.setModifiedDate(blogsEntry.getModifiedDate());
595                    blogsEntryImpl.setTitle(blogsEntry.getTitle());
596                    blogsEntryImpl.setUrlTitle(blogsEntry.getUrlTitle());
597                    blogsEntryImpl.setContent(blogsEntry.getContent());
598                    blogsEntryImpl.setDisplayDate(blogsEntry.getDisplayDate());
599                    blogsEntryImpl.setAllowPingbacks(blogsEntry.isAllowPingbacks());
600                    blogsEntryImpl.setAllowTrackbacks(blogsEntry.isAllowTrackbacks());
601                    blogsEntryImpl.setTrackbacks(blogsEntry.getTrackbacks());
602                    blogsEntryImpl.setStatus(blogsEntry.getStatus());
603                    blogsEntryImpl.setStatusByUserId(blogsEntry.getStatusByUserId());
604                    blogsEntryImpl.setStatusByUserName(blogsEntry.getStatusByUserName());
605                    blogsEntryImpl.setStatusDate(blogsEntry.getStatusDate());
606    
607                    return blogsEntryImpl;
608            }
609    
610            public BlogsEntry findByPrimaryKey(Serializable primaryKey)
611                    throws NoSuchModelException, SystemException {
612                    return findByPrimaryKey(((Long)primaryKey).longValue());
613            }
614    
615            public BlogsEntry findByPrimaryKey(long entryId)
616                    throws NoSuchEntryException, SystemException {
617                    BlogsEntry blogsEntry = fetchByPrimaryKey(entryId);
618    
619                    if (blogsEntry == null) {
620                            if (_log.isWarnEnabled()) {
621                                    _log.warn(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY + entryId);
622                            }
623    
624                            throw new NoSuchEntryException(_NO_SUCH_ENTITY_WITH_PRIMARY_KEY +
625                                    entryId);
626                    }
627    
628                    return blogsEntry;
629            }
630    
631            public BlogsEntry fetchByPrimaryKey(Serializable primaryKey)
632                    throws SystemException {
633                    return fetchByPrimaryKey(((Long)primaryKey).longValue());
634            }
635    
636            public BlogsEntry fetchByPrimaryKey(long entryId) throws SystemException {
637                    BlogsEntry blogsEntry = (BlogsEntry)EntityCacheUtil.getResult(BlogsEntryModelImpl.ENTITY_CACHE_ENABLED,
638                                    BlogsEntryImpl.class, entryId, this);
639    
640                    if (blogsEntry == null) {
641                            Session session = null;
642    
643                            try {
644                                    session = openSession();
645    
646                                    blogsEntry = (BlogsEntry)session.get(BlogsEntryImpl.class,
647                                                    new Long(entryId));
648                            }
649                            catch (Exception e) {
650                                    throw processException(e);
651                            }
652                            finally {
653                                    if (blogsEntry != null) {
654                                            cacheResult(blogsEntry);
655                                    }
656    
657                                    closeSession(session);
658                            }
659                    }
660    
661                    return blogsEntry;
662            }
663    
664            public List<BlogsEntry> findByUuid(String uuid) throws SystemException {
665                    return findByUuid(uuid, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
666            }
667    
668            public List<BlogsEntry> findByUuid(String uuid, int start, int end)
669                    throws SystemException {
670                    return findByUuid(uuid, start, end, null);
671            }
672    
673            public List<BlogsEntry> findByUuid(String uuid, int start, int end,
674                    OrderByComparator orderByComparator) throws SystemException {
675                    Object[] finderArgs = new Object[] {
676                                    uuid,
677                                    
678                                    String.valueOf(start), String.valueOf(end),
679                                    String.valueOf(orderByComparator)
680                            };
681    
682                    List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_UUID,
683                                    finderArgs, this);
684    
685                    if (list == null) {
686                            Session session = null;
687    
688                            try {
689                                    session = openSession();
690    
691                                    StringBundler query = null;
692    
693                                    if (orderByComparator != null) {
694                                            query = new StringBundler(3 +
695                                                            (orderByComparator.getOrderByFields().length * 3));
696                                    }
697                                    else {
698                                            query = new StringBundler(3);
699                                    }
700    
701                                    query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
702    
703                                    if (uuid == null) {
704                                            query.append(_FINDER_COLUMN_UUID_UUID_1);
705                                    }
706                                    else {
707                                            if (uuid.equals(StringPool.BLANK)) {
708                                                    query.append(_FINDER_COLUMN_UUID_UUID_3);
709                                            }
710                                            else {
711                                                    query.append(_FINDER_COLUMN_UUID_UUID_2);
712                                            }
713                                    }
714    
715                                    if (orderByComparator != null) {
716                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
717                                                    orderByComparator);
718                                    }
719    
720                                    else {
721                                            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
722                                    }
723    
724                                    String sql = query.toString();
725    
726                                    Query q = session.createQuery(sql);
727    
728                                    QueryPos qPos = QueryPos.getInstance(q);
729    
730                                    if (uuid != null) {
731                                            qPos.add(uuid);
732                                    }
733    
734                                    list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start,
735                                                    end);
736                            }
737                            catch (Exception e) {
738                                    throw processException(e);
739                            }
740                            finally {
741                                    if (list == null) {
742                                            list = new ArrayList<BlogsEntry>();
743                                    }
744    
745                                    cacheResult(list);
746    
747                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_UUID, finderArgs,
748                                            list);
749    
750                                    closeSession(session);
751                            }
752                    }
753    
754                    return list;
755            }
756    
757            public BlogsEntry findByUuid_First(String uuid,
758                    OrderByComparator orderByComparator)
759                    throws NoSuchEntryException, SystemException {
760                    List<BlogsEntry> list = findByUuid(uuid, 0, 1, orderByComparator);
761    
762                    if (list.isEmpty()) {
763                            StringBundler msg = new StringBundler(4);
764    
765                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
766    
767                            msg.append("uuid=");
768                            msg.append(uuid);
769    
770                            msg.append(StringPool.CLOSE_CURLY_BRACE);
771    
772                            throw new NoSuchEntryException(msg.toString());
773                    }
774                    else {
775                            return list.get(0);
776                    }
777            }
778    
779            public BlogsEntry findByUuid_Last(String uuid,
780                    OrderByComparator orderByComparator)
781                    throws NoSuchEntryException, SystemException {
782                    int count = countByUuid(uuid);
783    
784                    List<BlogsEntry> list = findByUuid(uuid, count - 1, count,
785                                    orderByComparator);
786    
787                    if (list.isEmpty()) {
788                            StringBundler msg = new StringBundler(4);
789    
790                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
791    
792                            msg.append("uuid=");
793                            msg.append(uuid);
794    
795                            msg.append(StringPool.CLOSE_CURLY_BRACE);
796    
797                            throw new NoSuchEntryException(msg.toString());
798                    }
799                    else {
800                            return list.get(0);
801                    }
802            }
803    
804            public BlogsEntry[] findByUuid_PrevAndNext(long entryId, String uuid,
805                    OrderByComparator orderByComparator)
806                    throws NoSuchEntryException, SystemException {
807                    BlogsEntry blogsEntry = findByPrimaryKey(entryId);
808    
809                    Session session = null;
810    
811                    try {
812                            session = openSession();
813    
814                            BlogsEntry[] array = new BlogsEntryImpl[3];
815    
816                            array[0] = getByUuid_PrevAndNext(session, blogsEntry, uuid,
817                                            orderByComparator, true);
818    
819                            array[1] = blogsEntry;
820    
821                            array[2] = getByUuid_PrevAndNext(session, blogsEntry, uuid,
822                                            orderByComparator, false);
823    
824                            return array;
825                    }
826                    catch (Exception e) {
827                            throw processException(e);
828                    }
829                    finally {
830                            closeSession(session);
831                    }
832            }
833    
834            protected BlogsEntry getByUuid_PrevAndNext(Session session,
835                    BlogsEntry blogsEntry, String uuid,
836                    OrderByComparator orderByComparator, boolean previous) {
837                    StringBundler query = null;
838    
839                    if (orderByComparator != null) {
840                            query = new StringBundler(6 +
841                                            (orderByComparator.getOrderByFields().length * 6));
842                    }
843                    else {
844                            query = new StringBundler(3);
845                    }
846    
847                    query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
848    
849                    if (uuid == null) {
850                            query.append(_FINDER_COLUMN_UUID_UUID_1);
851                    }
852                    else {
853                            if (uuid.equals(StringPool.BLANK)) {
854                                    query.append(_FINDER_COLUMN_UUID_UUID_3);
855                            }
856                            else {
857                                    query.append(_FINDER_COLUMN_UUID_UUID_2);
858                            }
859                    }
860    
861                    if (orderByComparator != null) {
862                            String[] orderByFields = orderByComparator.getOrderByFields();
863    
864                            if (orderByFields.length > 0) {
865                                    query.append(WHERE_AND);
866                            }
867    
868                            for (int i = 0; i < orderByFields.length; i++) {
869                                    query.append(_ORDER_BY_ENTITY_ALIAS);
870                                    query.append(orderByFields[i]);
871    
872                                    if ((i + 1) < orderByFields.length) {
873                                            if (orderByComparator.isAscending() ^ previous) {
874                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
875                                            }
876                                            else {
877                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
878                                            }
879                                    }
880                                    else {
881                                            if (orderByComparator.isAscending() ^ previous) {
882                                                    query.append(WHERE_GREATER_THAN);
883                                            }
884                                            else {
885                                                    query.append(WHERE_LESSER_THAN);
886                                            }
887                                    }
888                            }
889    
890                            query.append(ORDER_BY_CLAUSE);
891    
892                            for (int i = 0; i < orderByFields.length; i++) {
893                                    query.append(_ORDER_BY_ENTITY_ALIAS);
894                                    query.append(orderByFields[i]);
895    
896                                    if ((i + 1) < orderByFields.length) {
897                                            if (orderByComparator.isAscending() ^ previous) {
898                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
899                                            }
900                                            else {
901                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
902                                            }
903                                    }
904                                    else {
905                                            if (orderByComparator.isAscending() ^ previous) {
906                                                    query.append(ORDER_BY_ASC);
907                                            }
908                                            else {
909                                                    query.append(ORDER_BY_DESC);
910                                            }
911                                    }
912                            }
913                    }
914    
915                    else {
916                            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
917                    }
918    
919                    String sql = query.toString();
920    
921                    Query q = session.createQuery(sql);
922    
923                    q.setFirstResult(0);
924                    q.setMaxResults(2);
925    
926                    QueryPos qPos = QueryPos.getInstance(q);
927    
928                    if (uuid != null) {
929                            qPos.add(uuid);
930                    }
931    
932                    if (orderByComparator != null) {
933                            Object[] values = orderByComparator.getOrderByValues(blogsEntry);
934    
935                            for (Object value : values) {
936                                    qPos.add(value);
937                            }
938                    }
939    
940                    List<BlogsEntry> list = q.list();
941    
942                    if (list.size() == 2) {
943                            return list.get(1);
944                    }
945                    else {
946                            return null;
947                    }
948            }
949    
950            public BlogsEntry findByUUID_G(String uuid, long groupId)
951                    throws NoSuchEntryException, SystemException {
952                    BlogsEntry blogsEntry = fetchByUUID_G(uuid, groupId);
953    
954                    if (blogsEntry == null) {
955                            StringBundler msg = new StringBundler(6);
956    
957                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
958    
959                            msg.append("uuid=");
960                            msg.append(uuid);
961    
962                            msg.append(", groupId=");
963                            msg.append(groupId);
964    
965                            msg.append(StringPool.CLOSE_CURLY_BRACE);
966    
967                            if (_log.isWarnEnabled()) {
968                                    _log.warn(msg.toString());
969                            }
970    
971                            throw new NoSuchEntryException(msg.toString());
972                    }
973    
974                    return blogsEntry;
975            }
976    
977            public BlogsEntry fetchByUUID_G(String uuid, long groupId)
978                    throws SystemException {
979                    return fetchByUUID_G(uuid, groupId, true);
980            }
981    
982            public BlogsEntry fetchByUUID_G(String uuid, long groupId,
983                    boolean retrieveFromCache) throws SystemException {
984                    Object[] finderArgs = new Object[] { uuid, groupId };
985    
986                    Object result = null;
987    
988                    if (retrieveFromCache) {
989                            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_UUID_G,
990                                            finderArgs, this);
991                    }
992    
993                    if (result == null) {
994                            Session session = null;
995    
996                            try {
997                                    session = openSession();
998    
999                                    StringBundler query = new StringBundler(4);
1000    
1001                                    query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
1002    
1003                                    if (uuid == null) {
1004                                            query.append(_FINDER_COLUMN_UUID_G_UUID_1);
1005                                    }
1006                                    else {
1007                                            if (uuid.equals(StringPool.BLANK)) {
1008                                                    query.append(_FINDER_COLUMN_UUID_G_UUID_3);
1009                                            }
1010                                            else {
1011                                                    query.append(_FINDER_COLUMN_UUID_G_UUID_2);
1012                                            }
1013                                    }
1014    
1015                                    query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
1016    
1017                                    query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
1018    
1019                                    String sql = query.toString();
1020    
1021                                    Query q = session.createQuery(sql);
1022    
1023                                    QueryPos qPos = QueryPos.getInstance(q);
1024    
1025                                    if (uuid != null) {
1026                                            qPos.add(uuid);
1027                                    }
1028    
1029                                    qPos.add(groupId);
1030    
1031                                    List<BlogsEntry> list = q.list();
1032    
1033                                    result = list;
1034    
1035                                    BlogsEntry blogsEntry = null;
1036    
1037                                    if (list.isEmpty()) {
1038                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
1039                                                    finderArgs, list);
1040                                    }
1041                                    else {
1042                                            blogsEntry = list.get(0);
1043    
1044                                            cacheResult(blogsEntry);
1045    
1046                                            if ((blogsEntry.getUuid() == null) ||
1047                                                            !blogsEntry.getUuid().equals(uuid) ||
1048                                                            (blogsEntry.getGroupId() != groupId)) {
1049                                                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
1050                                                            finderArgs, blogsEntry);
1051                                            }
1052                                    }
1053    
1054                                    return blogsEntry;
1055                            }
1056                            catch (Exception e) {
1057                                    throw processException(e);
1058                            }
1059                            finally {
1060                                    if (result == null) {
1061                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_UUID_G,
1062                                                    finderArgs, new ArrayList<BlogsEntry>());
1063                                    }
1064    
1065                                    closeSession(session);
1066                            }
1067                    }
1068                    else {
1069                            if (result instanceof List<?>) {
1070                                    return null;
1071                            }
1072                            else {
1073                                    return (BlogsEntry)result;
1074                            }
1075                    }
1076            }
1077    
1078            public List<BlogsEntry> findByGroupId(long groupId)
1079                    throws SystemException {
1080                    return findByGroupId(groupId, QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
1081            }
1082    
1083            public List<BlogsEntry> findByGroupId(long groupId, int start, int end)
1084                    throws SystemException {
1085                    return findByGroupId(groupId, start, end, null);
1086            }
1087    
1088            public List<BlogsEntry> findByGroupId(long groupId, int start, int end,
1089                    OrderByComparator orderByComparator) throws SystemException {
1090                    Object[] finderArgs = new Object[] {
1091                                    groupId,
1092                                    
1093                                    String.valueOf(start), String.valueOf(end),
1094                                    String.valueOf(orderByComparator)
1095                            };
1096    
1097                    List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_GROUPID,
1098                                    finderArgs, this);
1099    
1100                    if (list == null) {
1101                            Session session = null;
1102    
1103                            try {
1104                                    session = openSession();
1105    
1106                                    StringBundler query = null;
1107    
1108                                    if (orderByComparator != null) {
1109                                            query = new StringBundler(3 +
1110                                                            (orderByComparator.getOrderByFields().length * 3));
1111                                    }
1112                                    else {
1113                                            query = new StringBundler(3);
1114                                    }
1115    
1116                                    query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
1117    
1118                                    query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1119    
1120                                    if (orderByComparator != null) {
1121                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1122                                                    orderByComparator);
1123                                    }
1124    
1125                                    else {
1126                                            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
1127                                    }
1128    
1129                                    String sql = query.toString();
1130    
1131                                    Query q = session.createQuery(sql);
1132    
1133                                    QueryPos qPos = QueryPos.getInstance(q);
1134    
1135                                    qPos.add(groupId);
1136    
1137                                    list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start,
1138                                                    end);
1139                            }
1140                            catch (Exception e) {
1141                                    throw processException(e);
1142                            }
1143                            finally {
1144                                    if (list == null) {
1145                                            list = new ArrayList<BlogsEntry>();
1146                                    }
1147    
1148                                    cacheResult(list);
1149    
1150                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_GROUPID,
1151                                            finderArgs, list);
1152    
1153                                    closeSession(session);
1154                            }
1155                    }
1156    
1157                    return list;
1158            }
1159    
1160            public BlogsEntry findByGroupId_First(long groupId,
1161                    OrderByComparator orderByComparator)
1162                    throws NoSuchEntryException, SystemException {
1163                    List<BlogsEntry> list = findByGroupId(groupId, 0, 1, orderByComparator);
1164    
1165                    if (list.isEmpty()) {
1166                            StringBundler msg = new StringBundler(4);
1167    
1168                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1169    
1170                            msg.append("groupId=");
1171                            msg.append(groupId);
1172    
1173                            msg.append(StringPool.CLOSE_CURLY_BRACE);
1174    
1175                            throw new NoSuchEntryException(msg.toString());
1176                    }
1177                    else {
1178                            return list.get(0);
1179                    }
1180            }
1181    
1182            public BlogsEntry findByGroupId_Last(long groupId,
1183                    OrderByComparator orderByComparator)
1184                    throws NoSuchEntryException, SystemException {
1185                    int count = countByGroupId(groupId);
1186    
1187                    List<BlogsEntry> list = findByGroupId(groupId, count - 1, count,
1188                                    orderByComparator);
1189    
1190                    if (list.isEmpty()) {
1191                            StringBundler msg = new StringBundler(4);
1192    
1193                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1194    
1195                            msg.append("groupId=");
1196                            msg.append(groupId);
1197    
1198                            msg.append(StringPool.CLOSE_CURLY_BRACE);
1199    
1200                            throw new NoSuchEntryException(msg.toString());
1201                    }
1202                    else {
1203                            return list.get(0);
1204                    }
1205            }
1206    
1207            public BlogsEntry[] findByGroupId_PrevAndNext(long entryId, long groupId,
1208                    OrderByComparator orderByComparator)
1209                    throws NoSuchEntryException, SystemException {
1210                    BlogsEntry blogsEntry = findByPrimaryKey(entryId);
1211    
1212                    Session session = null;
1213    
1214                    try {
1215                            session = openSession();
1216    
1217                            BlogsEntry[] array = new BlogsEntryImpl[3];
1218    
1219                            array[0] = getByGroupId_PrevAndNext(session, blogsEntry, groupId,
1220                                            orderByComparator, true);
1221    
1222                            array[1] = blogsEntry;
1223    
1224                            array[2] = getByGroupId_PrevAndNext(session, blogsEntry, groupId,
1225                                            orderByComparator, false);
1226    
1227                            return array;
1228                    }
1229                    catch (Exception e) {
1230                            throw processException(e);
1231                    }
1232                    finally {
1233                            closeSession(session);
1234                    }
1235            }
1236    
1237            protected BlogsEntry getByGroupId_PrevAndNext(Session session,
1238                    BlogsEntry blogsEntry, long groupId,
1239                    OrderByComparator orderByComparator, boolean previous) {
1240                    StringBundler query = null;
1241    
1242                    if (orderByComparator != null) {
1243                            query = new StringBundler(6 +
1244                                            (orderByComparator.getOrderByFields().length * 6));
1245                    }
1246                    else {
1247                            query = new StringBundler(3);
1248                    }
1249    
1250                    query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
1251    
1252                    query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1253    
1254                    if (orderByComparator != null) {
1255                            String[] orderByFields = orderByComparator.getOrderByFields();
1256    
1257                            if (orderByFields.length > 0) {
1258                                    query.append(WHERE_AND);
1259                            }
1260    
1261                            for (int i = 0; i < orderByFields.length; i++) {
1262                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1263                                    query.append(orderByFields[i]);
1264    
1265                                    if ((i + 1) < orderByFields.length) {
1266                                            if (orderByComparator.isAscending() ^ previous) {
1267                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
1268                                            }
1269                                            else {
1270                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
1271                                            }
1272                                    }
1273                                    else {
1274                                            if (orderByComparator.isAscending() ^ previous) {
1275                                                    query.append(WHERE_GREATER_THAN);
1276                                            }
1277                                            else {
1278                                                    query.append(WHERE_LESSER_THAN);
1279                                            }
1280                                    }
1281                            }
1282    
1283                            query.append(ORDER_BY_CLAUSE);
1284    
1285                            for (int i = 0; i < orderByFields.length; i++) {
1286                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1287                                    query.append(orderByFields[i]);
1288    
1289                                    if ((i + 1) < orderByFields.length) {
1290                                            if (orderByComparator.isAscending() ^ previous) {
1291                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
1292                                            }
1293                                            else {
1294                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
1295                                            }
1296                                    }
1297                                    else {
1298                                            if (orderByComparator.isAscending() ^ previous) {
1299                                                    query.append(ORDER_BY_ASC);
1300                                            }
1301                                            else {
1302                                                    query.append(ORDER_BY_DESC);
1303                                            }
1304                                    }
1305                            }
1306                    }
1307    
1308                    else {
1309                            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
1310                    }
1311    
1312                    String sql = query.toString();
1313    
1314                    Query q = session.createQuery(sql);
1315    
1316                    q.setFirstResult(0);
1317                    q.setMaxResults(2);
1318    
1319                    QueryPos qPos = QueryPos.getInstance(q);
1320    
1321                    qPos.add(groupId);
1322    
1323                    if (orderByComparator != null) {
1324                            Object[] values = orderByComparator.getOrderByValues(blogsEntry);
1325    
1326                            for (Object value : values) {
1327                                    qPos.add(value);
1328                            }
1329                    }
1330    
1331                    List<BlogsEntry> list = q.list();
1332    
1333                    if (list.size() == 2) {
1334                            return list.get(1);
1335                    }
1336                    else {
1337                            return null;
1338                    }
1339            }
1340    
1341            public List<BlogsEntry> filterFindByGroupId(long groupId)
1342                    throws SystemException {
1343                    return filterFindByGroupId(groupId, QueryUtil.ALL_POS,
1344                            QueryUtil.ALL_POS, null);
1345            }
1346    
1347            public List<BlogsEntry> filterFindByGroupId(long groupId, int start, int end)
1348                    throws SystemException {
1349                    return filterFindByGroupId(groupId, start, end, null);
1350            }
1351    
1352            public List<BlogsEntry> filterFindByGroupId(long groupId, int start,
1353                    int end, OrderByComparator orderByComparator) throws SystemException {
1354                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
1355                            return findByGroupId(groupId, start, end, orderByComparator);
1356                    }
1357    
1358                    Session session = null;
1359    
1360                    try {
1361                            session = openSession();
1362    
1363                            StringBundler query = null;
1364    
1365                            if (orderByComparator != null) {
1366                                    query = new StringBundler(3 +
1367                                                    (orderByComparator.getOrderByFields().length * 3));
1368                            }
1369                            else {
1370                                    query = new StringBundler(3);
1371                            }
1372    
1373                            query.append(_FILTER_SQL_SELECT_BLOGSENTRY_WHERE);
1374    
1375                            query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
1376    
1377                            if (orderByComparator != null) {
1378                                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1379                                            orderByComparator);
1380                            }
1381    
1382                            else {
1383                                    query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
1384                            }
1385    
1386                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
1387                                            BlogsEntry.class.getName(), _FILTER_COLUMN_PK,
1388                                            _FILTER_COLUMN_USERID, groupId);
1389    
1390                            SQLQuery q = session.createSQLQuery(sql);
1391    
1392                            q.addEntity(_FILTER_ENTITY_ALIAS, BlogsEntryImpl.class);
1393    
1394                            QueryPos qPos = QueryPos.getInstance(q);
1395    
1396                            qPos.add(groupId);
1397    
1398                            return (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start, end);
1399                    }
1400                    catch (Exception e) {
1401                            throw processException(e);
1402                    }
1403                    finally {
1404                            closeSession(session);
1405                    }
1406            }
1407    
1408            public List<BlogsEntry> findByCompanyId(long companyId)
1409                    throws SystemException {
1410                    return findByCompanyId(companyId, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
1411                            null);
1412            }
1413    
1414            public List<BlogsEntry> findByCompanyId(long companyId, int start, int end)
1415                    throws SystemException {
1416                    return findByCompanyId(companyId, start, end, null);
1417            }
1418    
1419            public List<BlogsEntry> findByCompanyId(long companyId, int start, int end,
1420                    OrderByComparator orderByComparator) throws SystemException {
1421                    Object[] finderArgs = new Object[] {
1422                                    companyId,
1423                                    
1424                                    String.valueOf(start), String.valueOf(end),
1425                                    String.valueOf(orderByComparator)
1426                            };
1427    
1428                    List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_COMPANYID,
1429                                    finderArgs, this);
1430    
1431                    if (list == null) {
1432                            Session session = null;
1433    
1434                            try {
1435                                    session = openSession();
1436    
1437                                    StringBundler query = null;
1438    
1439                                    if (orderByComparator != null) {
1440                                            query = new StringBundler(3 +
1441                                                            (orderByComparator.getOrderByFields().length * 3));
1442                                    }
1443                                    else {
1444                                            query = new StringBundler(3);
1445                                    }
1446    
1447                                    query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
1448    
1449                                    query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
1450    
1451                                    if (orderByComparator != null) {
1452                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1453                                                    orderByComparator);
1454                                    }
1455    
1456                                    else {
1457                                            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
1458                                    }
1459    
1460                                    String sql = query.toString();
1461    
1462                                    Query q = session.createQuery(sql);
1463    
1464                                    QueryPos qPos = QueryPos.getInstance(q);
1465    
1466                                    qPos.add(companyId);
1467    
1468                                    list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start,
1469                                                    end);
1470                            }
1471                            catch (Exception e) {
1472                                    throw processException(e);
1473                            }
1474                            finally {
1475                                    if (list == null) {
1476                                            list = new ArrayList<BlogsEntry>();
1477                                    }
1478    
1479                                    cacheResult(list);
1480    
1481                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_COMPANYID,
1482                                            finderArgs, list);
1483    
1484                                    closeSession(session);
1485                            }
1486                    }
1487    
1488                    return list;
1489            }
1490    
1491            public BlogsEntry findByCompanyId_First(long companyId,
1492                    OrderByComparator orderByComparator)
1493                    throws NoSuchEntryException, SystemException {
1494                    List<BlogsEntry> list = findByCompanyId(companyId, 0, 1,
1495                                    orderByComparator);
1496    
1497                    if (list.isEmpty()) {
1498                            StringBundler msg = new StringBundler(4);
1499    
1500                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1501    
1502                            msg.append("companyId=");
1503                            msg.append(companyId);
1504    
1505                            msg.append(StringPool.CLOSE_CURLY_BRACE);
1506    
1507                            throw new NoSuchEntryException(msg.toString());
1508                    }
1509                    else {
1510                            return list.get(0);
1511                    }
1512            }
1513    
1514            public BlogsEntry findByCompanyId_Last(long companyId,
1515                    OrderByComparator orderByComparator)
1516                    throws NoSuchEntryException, SystemException {
1517                    int count = countByCompanyId(companyId);
1518    
1519                    List<BlogsEntry> list = findByCompanyId(companyId, count - 1, count,
1520                                    orderByComparator);
1521    
1522                    if (list.isEmpty()) {
1523                            StringBundler msg = new StringBundler(4);
1524    
1525                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1526    
1527                            msg.append("companyId=");
1528                            msg.append(companyId);
1529    
1530                            msg.append(StringPool.CLOSE_CURLY_BRACE);
1531    
1532                            throw new NoSuchEntryException(msg.toString());
1533                    }
1534                    else {
1535                            return list.get(0);
1536                    }
1537            }
1538    
1539            public BlogsEntry[] findByCompanyId_PrevAndNext(long entryId,
1540                    long companyId, OrderByComparator orderByComparator)
1541                    throws NoSuchEntryException, SystemException {
1542                    BlogsEntry blogsEntry = findByPrimaryKey(entryId);
1543    
1544                    Session session = null;
1545    
1546                    try {
1547                            session = openSession();
1548    
1549                            BlogsEntry[] array = new BlogsEntryImpl[3];
1550    
1551                            array[0] = getByCompanyId_PrevAndNext(session, blogsEntry,
1552                                            companyId, orderByComparator, true);
1553    
1554                            array[1] = blogsEntry;
1555    
1556                            array[2] = getByCompanyId_PrevAndNext(session, blogsEntry,
1557                                            companyId, orderByComparator, false);
1558    
1559                            return array;
1560                    }
1561                    catch (Exception e) {
1562                            throw processException(e);
1563                    }
1564                    finally {
1565                            closeSession(session);
1566                    }
1567            }
1568    
1569            protected BlogsEntry getByCompanyId_PrevAndNext(Session session,
1570                    BlogsEntry blogsEntry, long companyId,
1571                    OrderByComparator orderByComparator, boolean previous) {
1572                    StringBundler query = null;
1573    
1574                    if (orderByComparator != null) {
1575                            query = new StringBundler(6 +
1576                                            (orderByComparator.getOrderByFields().length * 6));
1577                    }
1578                    else {
1579                            query = new StringBundler(3);
1580                    }
1581    
1582                    query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
1583    
1584                    query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
1585    
1586                    if (orderByComparator != null) {
1587                            String[] orderByFields = orderByComparator.getOrderByFields();
1588    
1589                            if (orderByFields.length > 0) {
1590                                    query.append(WHERE_AND);
1591                            }
1592    
1593                            for (int i = 0; i < orderByFields.length; i++) {
1594                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1595                                    query.append(orderByFields[i]);
1596    
1597                                    if ((i + 1) < orderByFields.length) {
1598                                            if (orderByComparator.isAscending() ^ previous) {
1599                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
1600                                            }
1601                                            else {
1602                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
1603                                            }
1604                                    }
1605                                    else {
1606                                            if (orderByComparator.isAscending() ^ previous) {
1607                                                    query.append(WHERE_GREATER_THAN);
1608                                            }
1609                                            else {
1610                                                    query.append(WHERE_LESSER_THAN);
1611                                            }
1612                                    }
1613                            }
1614    
1615                            query.append(ORDER_BY_CLAUSE);
1616    
1617                            for (int i = 0; i < orderByFields.length; i++) {
1618                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1619                                    query.append(orderByFields[i]);
1620    
1621                                    if ((i + 1) < orderByFields.length) {
1622                                            if (orderByComparator.isAscending() ^ previous) {
1623                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
1624                                            }
1625                                            else {
1626                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
1627                                            }
1628                                    }
1629                                    else {
1630                                            if (orderByComparator.isAscending() ^ previous) {
1631                                                    query.append(ORDER_BY_ASC);
1632                                            }
1633                                            else {
1634                                                    query.append(ORDER_BY_DESC);
1635                                            }
1636                                    }
1637                            }
1638                    }
1639    
1640                    else {
1641                            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
1642                    }
1643    
1644                    String sql = query.toString();
1645    
1646                    Query q = session.createQuery(sql);
1647    
1648                    q.setFirstResult(0);
1649                    q.setMaxResults(2);
1650    
1651                    QueryPos qPos = QueryPos.getInstance(q);
1652    
1653                    qPos.add(companyId);
1654    
1655                    if (orderByComparator != null) {
1656                            Object[] values = orderByComparator.getOrderByValues(blogsEntry);
1657    
1658                            for (Object value : values) {
1659                                    qPos.add(value);
1660                            }
1661                    }
1662    
1663                    List<BlogsEntry> list = q.list();
1664    
1665                    if (list.size() == 2) {
1666                            return list.get(1);
1667                    }
1668                    else {
1669                            return null;
1670                    }
1671            }
1672    
1673            public List<BlogsEntry> findByC_U(long companyId, long userId)
1674                    throws SystemException {
1675                    return findByC_U(companyId, userId, QueryUtil.ALL_POS,
1676                            QueryUtil.ALL_POS, null);
1677            }
1678    
1679            public List<BlogsEntry> findByC_U(long companyId, long userId, int start,
1680                    int end) throws SystemException {
1681                    return findByC_U(companyId, userId, start, end, null);
1682            }
1683    
1684            public List<BlogsEntry> findByC_U(long companyId, long userId, int start,
1685                    int end, OrderByComparator orderByComparator) throws SystemException {
1686                    Object[] finderArgs = new Object[] {
1687                                    companyId, userId,
1688                                    
1689                                    String.valueOf(start), String.valueOf(end),
1690                                    String.valueOf(orderByComparator)
1691                            };
1692    
1693                    List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_C_U,
1694                                    finderArgs, this);
1695    
1696                    if (list == null) {
1697                            Session session = null;
1698    
1699                            try {
1700                                    session = openSession();
1701    
1702                                    StringBundler query = null;
1703    
1704                                    if (orderByComparator != null) {
1705                                            query = new StringBundler(4 +
1706                                                            (orderByComparator.getOrderByFields().length * 3));
1707                                    }
1708                                    else {
1709                                            query = new StringBundler(4);
1710                                    }
1711    
1712                                    query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
1713    
1714                                    query.append(_FINDER_COLUMN_C_U_COMPANYID_2);
1715    
1716                                    query.append(_FINDER_COLUMN_C_U_USERID_2);
1717    
1718                                    if (orderByComparator != null) {
1719                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
1720                                                    orderByComparator);
1721                                    }
1722    
1723                                    else {
1724                                            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
1725                                    }
1726    
1727                                    String sql = query.toString();
1728    
1729                                    Query q = session.createQuery(sql);
1730    
1731                                    QueryPos qPos = QueryPos.getInstance(q);
1732    
1733                                    qPos.add(companyId);
1734    
1735                                    qPos.add(userId);
1736    
1737                                    list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start,
1738                                                    end);
1739                            }
1740                            catch (Exception e) {
1741                                    throw processException(e);
1742                            }
1743                            finally {
1744                                    if (list == null) {
1745                                            list = new ArrayList<BlogsEntry>();
1746                                    }
1747    
1748                                    cacheResult(list);
1749    
1750                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_C_U, finderArgs,
1751                                            list);
1752    
1753                                    closeSession(session);
1754                            }
1755                    }
1756    
1757                    return list;
1758            }
1759    
1760            public BlogsEntry findByC_U_First(long companyId, long userId,
1761                    OrderByComparator orderByComparator)
1762                    throws NoSuchEntryException, SystemException {
1763                    List<BlogsEntry> list = findByC_U(companyId, userId, 0, 1,
1764                                    orderByComparator);
1765    
1766                    if (list.isEmpty()) {
1767                            StringBundler msg = new StringBundler(6);
1768    
1769                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1770    
1771                            msg.append("companyId=");
1772                            msg.append(companyId);
1773    
1774                            msg.append(", userId=");
1775                            msg.append(userId);
1776    
1777                            msg.append(StringPool.CLOSE_CURLY_BRACE);
1778    
1779                            throw new NoSuchEntryException(msg.toString());
1780                    }
1781                    else {
1782                            return list.get(0);
1783                    }
1784            }
1785    
1786            public BlogsEntry findByC_U_Last(long companyId, long userId,
1787                    OrderByComparator orderByComparator)
1788                    throws NoSuchEntryException, SystemException {
1789                    int count = countByC_U(companyId, userId);
1790    
1791                    List<BlogsEntry> list = findByC_U(companyId, userId, count - 1, count,
1792                                    orderByComparator);
1793    
1794                    if (list.isEmpty()) {
1795                            StringBundler msg = new StringBundler(6);
1796    
1797                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
1798    
1799                            msg.append("companyId=");
1800                            msg.append(companyId);
1801    
1802                            msg.append(", userId=");
1803                            msg.append(userId);
1804    
1805                            msg.append(StringPool.CLOSE_CURLY_BRACE);
1806    
1807                            throw new NoSuchEntryException(msg.toString());
1808                    }
1809                    else {
1810                            return list.get(0);
1811                    }
1812            }
1813    
1814            public BlogsEntry[] findByC_U_PrevAndNext(long entryId, long companyId,
1815                    long userId, OrderByComparator orderByComparator)
1816                    throws NoSuchEntryException, SystemException {
1817                    BlogsEntry blogsEntry = findByPrimaryKey(entryId);
1818    
1819                    Session session = null;
1820    
1821                    try {
1822                            session = openSession();
1823    
1824                            BlogsEntry[] array = new BlogsEntryImpl[3];
1825    
1826                            array[0] = getByC_U_PrevAndNext(session, blogsEntry, companyId,
1827                                            userId, orderByComparator, true);
1828    
1829                            array[1] = blogsEntry;
1830    
1831                            array[2] = getByC_U_PrevAndNext(session, blogsEntry, companyId,
1832                                            userId, orderByComparator, false);
1833    
1834                            return array;
1835                    }
1836                    catch (Exception e) {
1837                            throw processException(e);
1838                    }
1839                    finally {
1840                            closeSession(session);
1841                    }
1842            }
1843    
1844            protected BlogsEntry getByC_U_PrevAndNext(Session session,
1845                    BlogsEntry blogsEntry, long companyId, long userId,
1846                    OrderByComparator orderByComparator, boolean previous) {
1847                    StringBundler query = null;
1848    
1849                    if (orderByComparator != null) {
1850                            query = new StringBundler(6 +
1851                                            (orderByComparator.getOrderByFields().length * 6));
1852                    }
1853                    else {
1854                            query = new StringBundler(3);
1855                    }
1856    
1857                    query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
1858    
1859                    query.append(_FINDER_COLUMN_C_U_COMPANYID_2);
1860    
1861                    query.append(_FINDER_COLUMN_C_U_USERID_2);
1862    
1863                    if (orderByComparator != null) {
1864                            String[] orderByFields = orderByComparator.getOrderByFields();
1865    
1866                            if (orderByFields.length > 0) {
1867                                    query.append(WHERE_AND);
1868                            }
1869    
1870                            for (int i = 0; i < orderByFields.length; i++) {
1871                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1872                                    query.append(orderByFields[i]);
1873    
1874                                    if ((i + 1) < orderByFields.length) {
1875                                            if (orderByComparator.isAscending() ^ previous) {
1876                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
1877                                            }
1878                                            else {
1879                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
1880                                            }
1881                                    }
1882                                    else {
1883                                            if (orderByComparator.isAscending() ^ previous) {
1884                                                    query.append(WHERE_GREATER_THAN);
1885                                            }
1886                                            else {
1887                                                    query.append(WHERE_LESSER_THAN);
1888                                            }
1889                                    }
1890                            }
1891    
1892                            query.append(ORDER_BY_CLAUSE);
1893    
1894                            for (int i = 0; i < orderByFields.length; i++) {
1895                                    query.append(_ORDER_BY_ENTITY_ALIAS);
1896                                    query.append(orderByFields[i]);
1897    
1898                                    if ((i + 1) < orderByFields.length) {
1899                                            if (orderByComparator.isAscending() ^ previous) {
1900                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
1901                                            }
1902                                            else {
1903                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
1904                                            }
1905                                    }
1906                                    else {
1907                                            if (orderByComparator.isAscending() ^ previous) {
1908                                                    query.append(ORDER_BY_ASC);
1909                                            }
1910                                            else {
1911                                                    query.append(ORDER_BY_DESC);
1912                                            }
1913                                    }
1914                            }
1915                    }
1916    
1917                    else {
1918                            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
1919                    }
1920    
1921                    String sql = query.toString();
1922    
1923                    Query q = session.createQuery(sql);
1924    
1925                    q.setFirstResult(0);
1926                    q.setMaxResults(2);
1927    
1928                    QueryPos qPos = QueryPos.getInstance(q);
1929    
1930                    qPos.add(companyId);
1931    
1932                    qPos.add(userId);
1933    
1934                    if (orderByComparator != null) {
1935                            Object[] values = orderByComparator.getOrderByValues(blogsEntry);
1936    
1937                            for (Object value : values) {
1938                                    qPos.add(value);
1939                            }
1940                    }
1941    
1942                    List<BlogsEntry> list = q.list();
1943    
1944                    if (list.size() == 2) {
1945                            return list.get(1);
1946                    }
1947                    else {
1948                            return null;
1949                    }
1950            }
1951    
1952            public List<BlogsEntry> findByC_LtD(long companyId, Date displayDate)
1953                    throws SystemException {
1954                    return findByC_LtD(companyId, displayDate, QueryUtil.ALL_POS,
1955                            QueryUtil.ALL_POS, null);
1956            }
1957    
1958            public List<BlogsEntry> findByC_LtD(long companyId, Date displayDate,
1959                    int start, int end) throws SystemException {
1960                    return findByC_LtD(companyId, displayDate, start, end, null);
1961            }
1962    
1963            public List<BlogsEntry> findByC_LtD(long companyId, Date displayDate,
1964                    int start, int end, OrderByComparator orderByComparator)
1965                    throws SystemException {
1966                    Object[] finderArgs = new Object[] {
1967                                    companyId, displayDate,
1968                                    
1969                                    String.valueOf(start), String.valueOf(end),
1970                                    String.valueOf(orderByComparator)
1971                            };
1972    
1973                    List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_C_LTD,
1974                                    finderArgs, this);
1975    
1976                    if (list == null) {
1977                            Session session = null;
1978    
1979                            try {
1980                                    session = openSession();
1981    
1982                                    StringBundler query = null;
1983    
1984                                    if (orderByComparator != null) {
1985                                            query = new StringBundler(4 +
1986                                                            (orderByComparator.getOrderByFields().length * 3));
1987                                    }
1988                                    else {
1989                                            query = new StringBundler(4);
1990                                    }
1991    
1992                                    query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
1993    
1994                                    query.append(_FINDER_COLUMN_C_LTD_COMPANYID_2);
1995    
1996                                    if (displayDate == null) {
1997                                            query.append(_FINDER_COLUMN_C_LTD_DISPLAYDATE_1);
1998                                    }
1999                                    else {
2000                                            query.append(_FINDER_COLUMN_C_LTD_DISPLAYDATE_2);
2001                                    }
2002    
2003                                    if (orderByComparator != null) {
2004                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2005                                                    orderByComparator);
2006                                    }
2007    
2008                                    else {
2009                                            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
2010                                    }
2011    
2012                                    String sql = query.toString();
2013    
2014                                    Query q = session.createQuery(sql);
2015    
2016                                    QueryPos qPos = QueryPos.getInstance(q);
2017    
2018                                    qPos.add(companyId);
2019    
2020                                    if (displayDate != null) {
2021                                            qPos.add(CalendarUtil.getTimestamp(displayDate));
2022                                    }
2023    
2024                                    list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start,
2025                                                    end);
2026                            }
2027                            catch (Exception e) {
2028                                    throw processException(e);
2029                            }
2030                            finally {
2031                                    if (list == null) {
2032                                            list = new ArrayList<BlogsEntry>();
2033                                    }
2034    
2035                                    cacheResult(list);
2036    
2037                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_C_LTD,
2038                                            finderArgs, list);
2039    
2040                                    closeSession(session);
2041                            }
2042                    }
2043    
2044                    return list;
2045            }
2046    
2047            public BlogsEntry findByC_LtD_First(long companyId, Date displayDate,
2048                    OrderByComparator orderByComparator)
2049                    throws NoSuchEntryException, SystemException {
2050                    List<BlogsEntry> list = findByC_LtD(companyId, displayDate, 0, 1,
2051                                    orderByComparator);
2052    
2053                    if (list.isEmpty()) {
2054                            StringBundler msg = new StringBundler(6);
2055    
2056                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2057    
2058                            msg.append("companyId=");
2059                            msg.append(companyId);
2060    
2061                            msg.append(", displayDate=");
2062                            msg.append(displayDate);
2063    
2064                            msg.append(StringPool.CLOSE_CURLY_BRACE);
2065    
2066                            throw new NoSuchEntryException(msg.toString());
2067                    }
2068                    else {
2069                            return list.get(0);
2070                    }
2071            }
2072    
2073            public BlogsEntry findByC_LtD_Last(long companyId, Date displayDate,
2074                    OrderByComparator orderByComparator)
2075                    throws NoSuchEntryException, SystemException {
2076                    int count = countByC_LtD(companyId, displayDate);
2077    
2078                    List<BlogsEntry> list = findByC_LtD(companyId, displayDate, count - 1,
2079                                    count, orderByComparator);
2080    
2081                    if (list.isEmpty()) {
2082                            StringBundler msg = new StringBundler(6);
2083    
2084                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2085    
2086                            msg.append("companyId=");
2087                            msg.append(companyId);
2088    
2089                            msg.append(", displayDate=");
2090                            msg.append(displayDate);
2091    
2092                            msg.append(StringPool.CLOSE_CURLY_BRACE);
2093    
2094                            throw new NoSuchEntryException(msg.toString());
2095                    }
2096                    else {
2097                            return list.get(0);
2098                    }
2099            }
2100    
2101            public BlogsEntry[] findByC_LtD_PrevAndNext(long entryId, long companyId,
2102                    Date displayDate, OrderByComparator orderByComparator)
2103                    throws NoSuchEntryException, SystemException {
2104                    BlogsEntry blogsEntry = findByPrimaryKey(entryId);
2105    
2106                    Session session = null;
2107    
2108                    try {
2109                            session = openSession();
2110    
2111                            BlogsEntry[] array = new BlogsEntryImpl[3];
2112    
2113                            array[0] = getByC_LtD_PrevAndNext(session, blogsEntry, companyId,
2114                                            displayDate, orderByComparator, true);
2115    
2116                            array[1] = blogsEntry;
2117    
2118                            array[2] = getByC_LtD_PrevAndNext(session, blogsEntry, companyId,
2119                                            displayDate, orderByComparator, false);
2120    
2121                            return array;
2122                    }
2123                    catch (Exception e) {
2124                            throw processException(e);
2125                    }
2126                    finally {
2127                            closeSession(session);
2128                    }
2129            }
2130    
2131            protected BlogsEntry getByC_LtD_PrevAndNext(Session session,
2132                    BlogsEntry blogsEntry, long companyId, Date displayDate,
2133                    OrderByComparator orderByComparator, boolean previous) {
2134                    StringBundler query = null;
2135    
2136                    if (orderByComparator != null) {
2137                            query = new StringBundler(6 +
2138                                            (orderByComparator.getOrderByFields().length * 6));
2139                    }
2140                    else {
2141                            query = new StringBundler(3);
2142                    }
2143    
2144                    query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
2145    
2146                    query.append(_FINDER_COLUMN_C_LTD_COMPANYID_2);
2147    
2148                    if (displayDate == null) {
2149                            query.append(_FINDER_COLUMN_C_LTD_DISPLAYDATE_1);
2150                    }
2151                    else {
2152                            query.append(_FINDER_COLUMN_C_LTD_DISPLAYDATE_2);
2153                    }
2154    
2155                    if (orderByComparator != null) {
2156                            String[] orderByFields = orderByComparator.getOrderByFields();
2157    
2158                            if (orderByFields.length > 0) {
2159                                    query.append(WHERE_AND);
2160                            }
2161    
2162                            for (int i = 0; i < orderByFields.length; i++) {
2163                                    query.append(_ORDER_BY_ENTITY_ALIAS);
2164                                    query.append(orderByFields[i]);
2165    
2166                                    if ((i + 1) < orderByFields.length) {
2167                                            if (orderByComparator.isAscending() ^ previous) {
2168                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
2169                                            }
2170                                            else {
2171                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
2172                                            }
2173                                    }
2174                                    else {
2175                                            if (orderByComparator.isAscending() ^ previous) {
2176                                                    query.append(WHERE_GREATER_THAN);
2177                                            }
2178                                            else {
2179                                                    query.append(WHERE_LESSER_THAN);
2180                                            }
2181                                    }
2182                            }
2183    
2184                            query.append(ORDER_BY_CLAUSE);
2185    
2186                            for (int i = 0; i < orderByFields.length; i++) {
2187                                    query.append(_ORDER_BY_ENTITY_ALIAS);
2188                                    query.append(orderByFields[i]);
2189    
2190                                    if ((i + 1) < orderByFields.length) {
2191                                            if (orderByComparator.isAscending() ^ previous) {
2192                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
2193                                            }
2194                                            else {
2195                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
2196                                            }
2197                                    }
2198                                    else {
2199                                            if (orderByComparator.isAscending() ^ previous) {
2200                                                    query.append(ORDER_BY_ASC);
2201                                            }
2202                                            else {
2203                                                    query.append(ORDER_BY_DESC);
2204                                            }
2205                                    }
2206                            }
2207                    }
2208    
2209                    else {
2210                            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
2211                    }
2212    
2213                    String sql = query.toString();
2214    
2215                    Query q = session.createQuery(sql);
2216    
2217                    q.setFirstResult(0);
2218                    q.setMaxResults(2);
2219    
2220                    QueryPos qPos = QueryPos.getInstance(q);
2221    
2222                    qPos.add(companyId);
2223    
2224                    if (displayDate != null) {
2225                            qPos.add(CalendarUtil.getTimestamp(displayDate));
2226                    }
2227    
2228                    if (orderByComparator != null) {
2229                            Object[] values = orderByComparator.getOrderByValues(blogsEntry);
2230    
2231                            for (Object value : values) {
2232                                    qPos.add(value);
2233                            }
2234                    }
2235    
2236                    List<BlogsEntry> list = q.list();
2237    
2238                    if (list.size() == 2) {
2239                            return list.get(1);
2240                    }
2241                    else {
2242                            return null;
2243                    }
2244            }
2245    
2246            public List<BlogsEntry> findByC_S(long companyId, int status)
2247                    throws SystemException {
2248                    return findByC_S(companyId, status, QueryUtil.ALL_POS,
2249                            QueryUtil.ALL_POS, null);
2250            }
2251    
2252            public List<BlogsEntry> findByC_S(long companyId, int status, int start,
2253                    int end) throws SystemException {
2254                    return findByC_S(companyId, status, start, end, null);
2255            }
2256    
2257            public List<BlogsEntry> findByC_S(long companyId, int status, int start,
2258                    int end, OrderByComparator orderByComparator) throws SystemException {
2259                    Object[] finderArgs = new Object[] {
2260                                    companyId, status,
2261                                    
2262                                    String.valueOf(start), String.valueOf(end),
2263                                    String.valueOf(orderByComparator)
2264                            };
2265    
2266                    List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_C_S,
2267                                    finderArgs, this);
2268    
2269                    if (list == null) {
2270                            Session session = null;
2271    
2272                            try {
2273                                    session = openSession();
2274    
2275                                    StringBundler query = null;
2276    
2277                                    if (orderByComparator != null) {
2278                                            query = new StringBundler(4 +
2279                                                            (orderByComparator.getOrderByFields().length * 3));
2280                                    }
2281                                    else {
2282                                            query = new StringBundler(4);
2283                                    }
2284    
2285                                    query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
2286    
2287                                    query.append(_FINDER_COLUMN_C_S_COMPANYID_2);
2288    
2289                                    query.append(_FINDER_COLUMN_C_S_STATUS_2);
2290    
2291                                    if (orderByComparator != null) {
2292                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2293                                                    orderByComparator);
2294                                    }
2295    
2296                                    else {
2297                                            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
2298                                    }
2299    
2300                                    String sql = query.toString();
2301    
2302                                    Query q = session.createQuery(sql);
2303    
2304                                    QueryPos qPos = QueryPos.getInstance(q);
2305    
2306                                    qPos.add(companyId);
2307    
2308                                    qPos.add(status);
2309    
2310                                    list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start,
2311                                                    end);
2312                            }
2313                            catch (Exception e) {
2314                                    throw processException(e);
2315                            }
2316                            finally {
2317                                    if (list == null) {
2318                                            list = new ArrayList<BlogsEntry>();
2319                                    }
2320    
2321                                    cacheResult(list);
2322    
2323                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_C_S, finderArgs,
2324                                            list);
2325    
2326                                    closeSession(session);
2327                            }
2328                    }
2329    
2330                    return list;
2331            }
2332    
2333            public BlogsEntry findByC_S_First(long companyId, int status,
2334                    OrderByComparator orderByComparator)
2335                    throws NoSuchEntryException, SystemException {
2336                    List<BlogsEntry> list = findByC_S(companyId, status, 0, 1,
2337                                    orderByComparator);
2338    
2339                    if (list.isEmpty()) {
2340                            StringBundler msg = new StringBundler(6);
2341    
2342                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2343    
2344                            msg.append("companyId=");
2345                            msg.append(companyId);
2346    
2347                            msg.append(", status=");
2348                            msg.append(status);
2349    
2350                            msg.append(StringPool.CLOSE_CURLY_BRACE);
2351    
2352                            throw new NoSuchEntryException(msg.toString());
2353                    }
2354                    else {
2355                            return list.get(0);
2356                    }
2357            }
2358    
2359            public BlogsEntry findByC_S_Last(long companyId, int status,
2360                    OrderByComparator orderByComparator)
2361                    throws NoSuchEntryException, SystemException {
2362                    int count = countByC_S(companyId, status);
2363    
2364                    List<BlogsEntry> list = findByC_S(companyId, status, count - 1, count,
2365                                    orderByComparator);
2366    
2367                    if (list.isEmpty()) {
2368                            StringBundler msg = new StringBundler(6);
2369    
2370                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2371    
2372                            msg.append("companyId=");
2373                            msg.append(companyId);
2374    
2375                            msg.append(", status=");
2376                            msg.append(status);
2377    
2378                            msg.append(StringPool.CLOSE_CURLY_BRACE);
2379    
2380                            throw new NoSuchEntryException(msg.toString());
2381                    }
2382                    else {
2383                            return list.get(0);
2384                    }
2385            }
2386    
2387            public BlogsEntry[] findByC_S_PrevAndNext(long entryId, long companyId,
2388                    int status, OrderByComparator orderByComparator)
2389                    throws NoSuchEntryException, SystemException {
2390                    BlogsEntry blogsEntry = findByPrimaryKey(entryId);
2391    
2392                    Session session = null;
2393    
2394                    try {
2395                            session = openSession();
2396    
2397                            BlogsEntry[] array = new BlogsEntryImpl[3];
2398    
2399                            array[0] = getByC_S_PrevAndNext(session, blogsEntry, companyId,
2400                                            status, orderByComparator, true);
2401    
2402                            array[1] = blogsEntry;
2403    
2404                            array[2] = getByC_S_PrevAndNext(session, blogsEntry, companyId,
2405                                            status, orderByComparator, false);
2406    
2407                            return array;
2408                    }
2409                    catch (Exception e) {
2410                            throw processException(e);
2411                    }
2412                    finally {
2413                            closeSession(session);
2414                    }
2415            }
2416    
2417            protected BlogsEntry getByC_S_PrevAndNext(Session session,
2418                    BlogsEntry blogsEntry, long companyId, int status,
2419                    OrderByComparator orderByComparator, boolean previous) {
2420                    StringBundler query = null;
2421    
2422                    if (orderByComparator != null) {
2423                            query = new StringBundler(6 +
2424                                            (orderByComparator.getOrderByFields().length * 6));
2425                    }
2426                    else {
2427                            query = new StringBundler(3);
2428                    }
2429    
2430                    query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
2431    
2432                    query.append(_FINDER_COLUMN_C_S_COMPANYID_2);
2433    
2434                    query.append(_FINDER_COLUMN_C_S_STATUS_2);
2435    
2436                    if (orderByComparator != null) {
2437                            String[] orderByFields = orderByComparator.getOrderByFields();
2438    
2439                            if (orderByFields.length > 0) {
2440                                    query.append(WHERE_AND);
2441                            }
2442    
2443                            for (int i = 0; i < orderByFields.length; i++) {
2444                                    query.append(_ORDER_BY_ENTITY_ALIAS);
2445                                    query.append(orderByFields[i]);
2446    
2447                                    if ((i + 1) < orderByFields.length) {
2448                                            if (orderByComparator.isAscending() ^ previous) {
2449                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
2450                                            }
2451                                            else {
2452                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
2453                                            }
2454                                    }
2455                                    else {
2456                                            if (orderByComparator.isAscending() ^ previous) {
2457                                                    query.append(WHERE_GREATER_THAN);
2458                                            }
2459                                            else {
2460                                                    query.append(WHERE_LESSER_THAN);
2461                                            }
2462                                    }
2463                            }
2464    
2465                            query.append(ORDER_BY_CLAUSE);
2466    
2467                            for (int i = 0; i < orderByFields.length; i++) {
2468                                    query.append(_ORDER_BY_ENTITY_ALIAS);
2469                                    query.append(orderByFields[i]);
2470    
2471                                    if ((i + 1) < orderByFields.length) {
2472                                            if (orderByComparator.isAscending() ^ previous) {
2473                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
2474                                            }
2475                                            else {
2476                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
2477                                            }
2478                                    }
2479                                    else {
2480                                            if (orderByComparator.isAscending() ^ previous) {
2481                                                    query.append(ORDER_BY_ASC);
2482                                            }
2483                                            else {
2484                                                    query.append(ORDER_BY_DESC);
2485                                            }
2486                                    }
2487                            }
2488                    }
2489    
2490                    else {
2491                            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
2492                    }
2493    
2494                    String sql = query.toString();
2495    
2496                    Query q = session.createQuery(sql);
2497    
2498                    q.setFirstResult(0);
2499                    q.setMaxResults(2);
2500    
2501                    QueryPos qPos = QueryPos.getInstance(q);
2502    
2503                    qPos.add(companyId);
2504    
2505                    qPos.add(status);
2506    
2507                    if (orderByComparator != null) {
2508                            Object[] values = orderByComparator.getOrderByValues(blogsEntry);
2509    
2510                            for (Object value : values) {
2511                                    qPos.add(value);
2512                            }
2513                    }
2514    
2515                    List<BlogsEntry> list = q.list();
2516    
2517                    if (list.size() == 2) {
2518                            return list.get(1);
2519                    }
2520                    else {
2521                            return null;
2522                    }
2523            }
2524    
2525            public BlogsEntry findByG_UT(long groupId, String urlTitle)
2526                    throws NoSuchEntryException, SystemException {
2527                    BlogsEntry blogsEntry = fetchByG_UT(groupId, urlTitle);
2528    
2529                    if (blogsEntry == null) {
2530                            StringBundler msg = new StringBundler(6);
2531    
2532                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2533    
2534                            msg.append("groupId=");
2535                            msg.append(groupId);
2536    
2537                            msg.append(", urlTitle=");
2538                            msg.append(urlTitle);
2539    
2540                            msg.append(StringPool.CLOSE_CURLY_BRACE);
2541    
2542                            if (_log.isWarnEnabled()) {
2543                                    _log.warn(msg.toString());
2544                            }
2545    
2546                            throw new NoSuchEntryException(msg.toString());
2547                    }
2548    
2549                    return blogsEntry;
2550            }
2551    
2552            public BlogsEntry fetchByG_UT(long groupId, String urlTitle)
2553                    throws SystemException {
2554                    return fetchByG_UT(groupId, urlTitle, true);
2555            }
2556    
2557            public BlogsEntry fetchByG_UT(long groupId, String urlTitle,
2558                    boolean retrieveFromCache) throws SystemException {
2559                    Object[] finderArgs = new Object[] { groupId, urlTitle };
2560    
2561                    Object result = null;
2562    
2563                    if (retrieveFromCache) {
2564                            result = FinderCacheUtil.getResult(FINDER_PATH_FETCH_BY_G_UT,
2565                                            finderArgs, this);
2566                    }
2567    
2568                    if (result == null) {
2569                            Session session = null;
2570    
2571                            try {
2572                                    session = openSession();
2573    
2574                                    StringBundler query = new StringBundler(4);
2575    
2576                                    query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
2577    
2578                                    query.append(_FINDER_COLUMN_G_UT_GROUPID_2);
2579    
2580                                    if (urlTitle == null) {
2581                                            query.append(_FINDER_COLUMN_G_UT_URLTITLE_1);
2582                                    }
2583                                    else {
2584                                            if (urlTitle.equals(StringPool.BLANK)) {
2585                                                    query.append(_FINDER_COLUMN_G_UT_URLTITLE_3);
2586                                            }
2587                                            else {
2588                                                    query.append(_FINDER_COLUMN_G_UT_URLTITLE_2);
2589                                            }
2590                                    }
2591    
2592                                    query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
2593    
2594                                    String sql = query.toString();
2595    
2596                                    Query q = session.createQuery(sql);
2597    
2598                                    QueryPos qPos = QueryPos.getInstance(q);
2599    
2600                                    qPos.add(groupId);
2601    
2602                                    if (urlTitle != null) {
2603                                            qPos.add(urlTitle);
2604                                    }
2605    
2606                                    List<BlogsEntry> list = q.list();
2607    
2608                                    result = list;
2609    
2610                                    BlogsEntry blogsEntry = null;
2611    
2612                                    if (list.isEmpty()) {
2613                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_UT,
2614                                                    finderArgs, list);
2615                                    }
2616                                    else {
2617                                            blogsEntry = list.get(0);
2618    
2619                                            cacheResult(blogsEntry);
2620    
2621                                            if ((blogsEntry.getGroupId() != groupId) ||
2622                                                            (blogsEntry.getUrlTitle() == null) ||
2623                                                            !blogsEntry.getUrlTitle().equals(urlTitle)) {
2624                                                    FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_UT,
2625                                                            finderArgs, blogsEntry);
2626                                            }
2627                                    }
2628    
2629                                    return blogsEntry;
2630                            }
2631                            catch (Exception e) {
2632                                    throw processException(e);
2633                            }
2634                            finally {
2635                                    if (result == null) {
2636                                            FinderCacheUtil.putResult(FINDER_PATH_FETCH_BY_G_UT,
2637                                                    finderArgs, new ArrayList<BlogsEntry>());
2638                                    }
2639    
2640                                    closeSession(session);
2641                            }
2642                    }
2643                    else {
2644                            if (result instanceof List<?>) {
2645                                    return null;
2646                            }
2647                            else {
2648                                    return (BlogsEntry)result;
2649                            }
2650                    }
2651            }
2652    
2653            public List<BlogsEntry> findByG_LtD(long groupId, Date displayDate)
2654                    throws SystemException {
2655                    return findByG_LtD(groupId, displayDate, QueryUtil.ALL_POS,
2656                            QueryUtil.ALL_POS, null);
2657            }
2658    
2659            public List<BlogsEntry> findByG_LtD(long groupId, Date displayDate,
2660                    int start, int end) throws SystemException {
2661                    return findByG_LtD(groupId, displayDate, start, end, null);
2662            }
2663    
2664            public List<BlogsEntry> findByG_LtD(long groupId, Date displayDate,
2665                    int start, int end, OrderByComparator orderByComparator)
2666                    throws SystemException {
2667                    Object[] finderArgs = new Object[] {
2668                                    groupId, displayDate,
2669                                    
2670                                    String.valueOf(start), String.valueOf(end),
2671                                    String.valueOf(orderByComparator)
2672                            };
2673    
2674                    List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_LTD,
2675                                    finderArgs, this);
2676    
2677                    if (list == null) {
2678                            Session session = null;
2679    
2680                            try {
2681                                    session = openSession();
2682    
2683                                    StringBundler query = null;
2684    
2685                                    if (orderByComparator != null) {
2686                                            query = new StringBundler(4 +
2687                                                            (orderByComparator.getOrderByFields().length * 3));
2688                                    }
2689                                    else {
2690                                            query = new StringBundler(4);
2691                                    }
2692    
2693                                    query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
2694    
2695                                    query.append(_FINDER_COLUMN_G_LTD_GROUPID_2);
2696    
2697                                    if (displayDate == null) {
2698                                            query.append(_FINDER_COLUMN_G_LTD_DISPLAYDATE_1);
2699                                    }
2700                                    else {
2701                                            query.append(_FINDER_COLUMN_G_LTD_DISPLAYDATE_2);
2702                                    }
2703    
2704                                    if (orderByComparator != null) {
2705                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2706                                                    orderByComparator);
2707                                    }
2708    
2709                                    else {
2710                                            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
2711                                    }
2712    
2713                                    String sql = query.toString();
2714    
2715                                    Query q = session.createQuery(sql);
2716    
2717                                    QueryPos qPos = QueryPos.getInstance(q);
2718    
2719                                    qPos.add(groupId);
2720    
2721                                    if (displayDate != null) {
2722                                            qPos.add(CalendarUtil.getTimestamp(displayDate));
2723                                    }
2724    
2725                                    list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start,
2726                                                    end);
2727                            }
2728                            catch (Exception e) {
2729                                    throw processException(e);
2730                            }
2731                            finally {
2732                                    if (list == null) {
2733                                            list = new ArrayList<BlogsEntry>();
2734                                    }
2735    
2736                                    cacheResult(list);
2737    
2738                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_LTD,
2739                                            finderArgs, list);
2740    
2741                                    closeSession(session);
2742                            }
2743                    }
2744    
2745                    return list;
2746            }
2747    
2748            public BlogsEntry findByG_LtD_First(long groupId, Date displayDate,
2749                    OrderByComparator orderByComparator)
2750                    throws NoSuchEntryException, SystemException {
2751                    List<BlogsEntry> list = findByG_LtD(groupId, displayDate, 0, 1,
2752                                    orderByComparator);
2753    
2754                    if (list.isEmpty()) {
2755                            StringBundler msg = new StringBundler(6);
2756    
2757                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2758    
2759                            msg.append("groupId=");
2760                            msg.append(groupId);
2761    
2762                            msg.append(", displayDate=");
2763                            msg.append(displayDate);
2764    
2765                            msg.append(StringPool.CLOSE_CURLY_BRACE);
2766    
2767                            throw new NoSuchEntryException(msg.toString());
2768                    }
2769                    else {
2770                            return list.get(0);
2771                    }
2772            }
2773    
2774            public BlogsEntry findByG_LtD_Last(long groupId, Date displayDate,
2775                    OrderByComparator orderByComparator)
2776                    throws NoSuchEntryException, SystemException {
2777                    int count = countByG_LtD(groupId, displayDate);
2778    
2779                    List<BlogsEntry> list = findByG_LtD(groupId, displayDate, count - 1,
2780                                    count, orderByComparator);
2781    
2782                    if (list.isEmpty()) {
2783                            StringBundler msg = new StringBundler(6);
2784    
2785                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
2786    
2787                            msg.append("groupId=");
2788                            msg.append(groupId);
2789    
2790                            msg.append(", displayDate=");
2791                            msg.append(displayDate);
2792    
2793                            msg.append(StringPool.CLOSE_CURLY_BRACE);
2794    
2795                            throw new NoSuchEntryException(msg.toString());
2796                    }
2797                    else {
2798                            return list.get(0);
2799                    }
2800            }
2801    
2802            public BlogsEntry[] findByG_LtD_PrevAndNext(long entryId, long groupId,
2803                    Date displayDate, OrderByComparator orderByComparator)
2804                    throws NoSuchEntryException, SystemException {
2805                    BlogsEntry blogsEntry = findByPrimaryKey(entryId);
2806    
2807                    Session session = null;
2808    
2809                    try {
2810                            session = openSession();
2811    
2812                            BlogsEntry[] array = new BlogsEntryImpl[3];
2813    
2814                            array[0] = getByG_LtD_PrevAndNext(session, blogsEntry, groupId,
2815                                            displayDate, orderByComparator, true);
2816    
2817                            array[1] = blogsEntry;
2818    
2819                            array[2] = getByG_LtD_PrevAndNext(session, blogsEntry, groupId,
2820                                            displayDate, orderByComparator, false);
2821    
2822                            return array;
2823                    }
2824                    catch (Exception e) {
2825                            throw processException(e);
2826                    }
2827                    finally {
2828                            closeSession(session);
2829                    }
2830            }
2831    
2832            protected BlogsEntry getByG_LtD_PrevAndNext(Session session,
2833                    BlogsEntry blogsEntry, long groupId, Date displayDate,
2834                    OrderByComparator orderByComparator, boolean previous) {
2835                    StringBundler query = null;
2836    
2837                    if (orderByComparator != null) {
2838                            query = new StringBundler(6 +
2839                                            (orderByComparator.getOrderByFields().length * 6));
2840                    }
2841                    else {
2842                            query = new StringBundler(3);
2843                    }
2844    
2845                    query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
2846    
2847                    query.append(_FINDER_COLUMN_G_LTD_GROUPID_2);
2848    
2849                    if (displayDate == null) {
2850                            query.append(_FINDER_COLUMN_G_LTD_DISPLAYDATE_1);
2851                    }
2852                    else {
2853                            query.append(_FINDER_COLUMN_G_LTD_DISPLAYDATE_2);
2854                    }
2855    
2856                    if (orderByComparator != null) {
2857                            String[] orderByFields = orderByComparator.getOrderByFields();
2858    
2859                            if (orderByFields.length > 0) {
2860                                    query.append(WHERE_AND);
2861                            }
2862    
2863                            for (int i = 0; i < orderByFields.length; i++) {
2864                                    query.append(_ORDER_BY_ENTITY_ALIAS);
2865                                    query.append(orderByFields[i]);
2866    
2867                                    if ((i + 1) < orderByFields.length) {
2868                                            if (orderByComparator.isAscending() ^ previous) {
2869                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
2870                                            }
2871                                            else {
2872                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
2873                                            }
2874                                    }
2875                                    else {
2876                                            if (orderByComparator.isAscending() ^ previous) {
2877                                                    query.append(WHERE_GREATER_THAN);
2878                                            }
2879                                            else {
2880                                                    query.append(WHERE_LESSER_THAN);
2881                                            }
2882                                    }
2883                            }
2884    
2885                            query.append(ORDER_BY_CLAUSE);
2886    
2887                            for (int i = 0; i < orderByFields.length; i++) {
2888                                    query.append(_ORDER_BY_ENTITY_ALIAS);
2889                                    query.append(orderByFields[i]);
2890    
2891                                    if ((i + 1) < orderByFields.length) {
2892                                            if (orderByComparator.isAscending() ^ previous) {
2893                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
2894                                            }
2895                                            else {
2896                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
2897                                            }
2898                                    }
2899                                    else {
2900                                            if (orderByComparator.isAscending() ^ previous) {
2901                                                    query.append(ORDER_BY_ASC);
2902                                            }
2903                                            else {
2904                                                    query.append(ORDER_BY_DESC);
2905                                            }
2906                                    }
2907                            }
2908                    }
2909    
2910                    else {
2911                            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
2912                    }
2913    
2914                    String sql = query.toString();
2915    
2916                    Query q = session.createQuery(sql);
2917    
2918                    q.setFirstResult(0);
2919                    q.setMaxResults(2);
2920    
2921                    QueryPos qPos = QueryPos.getInstance(q);
2922    
2923                    qPos.add(groupId);
2924    
2925                    if (displayDate != null) {
2926                            qPos.add(CalendarUtil.getTimestamp(displayDate));
2927                    }
2928    
2929                    if (orderByComparator != null) {
2930                            Object[] values = orderByComparator.getOrderByValues(blogsEntry);
2931    
2932                            for (Object value : values) {
2933                                    qPos.add(value);
2934                            }
2935                    }
2936    
2937                    List<BlogsEntry> list = q.list();
2938    
2939                    if (list.size() == 2) {
2940                            return list.get(1);
2941                    }
2942                    else {
2943                            return null;
2944                    }
2945            }
2946    
2947            public List<BlogsEntry> filterFindByG_LtD(long groupId, Date displayDate)
2948                    throws SystemException {
2949                    return filterFindByG_LtD(groupId, displayDate, QueryUtil.ALL_POS,
2950                            QueryUtil.ALL_POS, null);
2951            }
2952    
2953            public List<BlogsEntry> filterFindByG_LtD(long groupId, Date displayDate,
2954                    int start, int end) throws SystemException {
2955                    return filterFindByG_LtD(groupId, displayDate, start, end, null);
2956            }
2957    
2958            public List<BlogsEntry> filterFindByG_LtD(long groupId, Date displayDate,
2959                    int start, int end, OrderByComparator orderByComparator)
2960                    throws SystemException {
2961                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
2962                            return findByG_LtD(groupId, displayDate, start, end,
2963                                    orderByComparator);
2964                    }
2965    
2966                    Session session = null;
2967    
2968                    try {
2969                            session = openSession();
2970    
2971                            StringBundler query = null;
2972    
2973                            if (orderByComparator != null) {
2974                                    query = new StringBundler(4 +
2975                                                    (orderByComparator.getOrderByFields().length * 3));
2976                            }
2977                            else {
2978                                    query = new StringBundler(4);
2979                            }
2980    
2981                            query.append(_FILTER_SQL_SELECT_BLOGSENTRY_WHERE);
2982    
2983                            query.append(_FINDER_COLUMN_G_LTD_GROUPID_2);
2984    
2985                            if (displayDate == null) {
2986                                    query.append(_FINDER_COLUMN_G_LTD_DISPLAYDATE_1);
2987                            }
2988                            else {
2989                                    query.append(_FINDER_COLUMN_G_LTD_DISPLAYDATE_2);
2990                            }
2991    
2992                            if (orderByComparator != null) {
2993                                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
2994                                            orderByComparator);
2995                            }
2996    
2997                            else {
2998                                    query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
2999                            }
3000    
3001                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
3002                                            BlogsEntry.class.getName(), _FILTER_COLUMN_PK,
3003                                            _FILTER_COLUMN_USERID, groupId);
3004    
3005                            SQLQuery q = session.createSQLQuery(sql);
3006    
3007                            q.addEntity(_FILTER_ENTITY_ALIAS, BlogsEntryImpl.class);
3008    
3009                            QueryPos qPos = QueryPos.getInstance(q);
3010    
3011                            qPos.add(groupId);
3012    
3013                            if (displayDate != null) {
3014                                    qPos.add(CalendarUtil.getTimestamp(displayDate));
3015                            }
3016    
3017                            return (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start, end);
3018                    }
3019                    catch (Exception e) {
3020                            throw processException(e);
3021                    }
3022                    finally {
3023                            closeSession(session);
3024                    }
3025            }
3026    
3027            public List<BlogsEntry> findByG_S(long groupId, int status)
3028                    throws SystemException {
3029                    return findByG_S(groupId, status, QueryUtil.ALL_POS, QueryUtil.ALL_POS,
3030                            null);
3031            }
3032    
3033            public List<BlogsEntry> findByG_S(long groupId, int status, int start,
3034                    int end) throws SystemException {
3035                    return findByG_S(groupId, status, start, end, null);
3036            }
3037    
3038            public List<BlogsEntry> findByG_S(long groupId, int status, int start,
3039                    int end, OrderByComparator orderByComparator) throws SystemException {
3040                    Object[] finderArgs = new Object[] {
3041                                    groupId, status,
3042                                    
3043                                    String.valueOf(start), String.valueOf(end),
3044                                    String.valueOf(orderByComparator)
3045                            };
3046    
3047                    List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_S,
3048                                    finderArgs, this);
3049    
3050                    if (list == null) {
3051                            Session session = null;
3052    
3053                            try {
3054                                    session = openSession();
3055    
3056                                    StringBundler query = null;
3057    
3058                                    if (orderByComparator != null) {
3059                                            query = new StringBundler(4 +
3060                                                            (orderByComparator.getOrderByFields().length * 3));
3061                                    }
3062                                    else {
3063                                            query = new StringBundler(4);
3064                                    }
3065    
3066                                    query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
3067    
3068                                    query.append(_FINDER_COLUMN_G_S_GROUPID_2);
3069    
3070                                    query.append(_FINDER_COLUMN_G_S_STATUS_2);
3071    
3072                                    if (orderByComparator != null) {
3073                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
3074                                                    orderByComparator);
3075                                    }
3076    
3077                                    else {
3078                                            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
3079                                    }
3080    
3081                                    String sql = query.toString();
3082    
3083                                    Query q = session.createQuery(sql);
3084    
3085                                    QueryPos qPos = QueryPos.getInstance(q);
3086    
3087                                    qPos.add(groupId);
3088    
3089                                    qPos.add(status);
3090    
3091                                    list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start,
3092                                                    end);
3093                            }
3094                            catch (Exception e) {
3095                                    throw processException(e);
3096                            }
3097                            finally {
3098                                    if (list == null) {
3099                                            list = new ArrayList<BlogsEntry>();
3100                                    }
3101    
3102                                    cacheResult(list);
3103    
3104                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_S, finderArgs,
3105                                            list);
3106    
3107                                    closeSession(session);
3108                            }
3109                    }
3110    
3111                    return list;
3112            }
3113    
3114            public BlogsEntry findByG_S_First(long groupId, int status,
3115                    OrderByComparator orderByComparator)
3116                    throws NoSuchEntryException, SystemException {
3117                    List<BlogsEntry> list = findByG_S(groupId, status, 0, 1,
3118                                    orderByComparator);
3119    
3120                    if (list.isEmpty()) {
3121                            StringBundler msg = new StringBundler(6);
3122    
3123                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3124    
3125                            msg.append("groupId=");
3126                            msg.append(groupId);
3127    
3128                            msg.append(", status=");
3129                            msg.append(status);
3130    
3131                            msg.append(StringPool.CLOSE_CURLY_BRACE);
3132    
3133                            throw new NoSuchEntryException(msg.toString());
3134                    }
3135                    else {
3136                            return list.get(0);
3137                    }
3138            }
3139    
3140            public BlogsEntry findByG_S_Last(long groupId, int status,
3141                    OrderByComparator orderByComparator)
3142                    throws NoSuchEntryException, SystemException {
3143                    int count = countByG_S(groupId, status);
3144    
3145                    List<BlogsEntry> list = findByG_S(groupId, status, count - 1, count,
3146                                    orderByComparator);
3147    
3148                    if (list.isEmpty()) {
3149                            StringBundler msg = new StringBundler(6);
3150    
3151                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3152    
3153                            msg.append("groupId=");
3154                            msg.append(groupId);
3155    
3156                            msg.append(", status=");
3157                            msg.append(status);
3158    
3159                            msg.append(StringPool.CLOSE_CURLY_BRACE);
3160    
3161                            throw new NoSuchEntryException(msg.toString());
3162                    }
3163                    else {
3164                            return list.get(0);
3165                    }
3166            }
3167    
3168            public BlogsEntry[] findByG_S_PrevAndNext(long entryId, long groupId,
3169                    int status, OrderByComparator orderByComparator)
3170                    throws NoSuchEntryException, SystemException {
3171                    BlogsEntry blogsEntry = findByPrimaryKey(entryId);
3172    
3173                    Session session = null;
3174    
3175                    try {
3176                            session = openSession();
3177    
3178                            BlogsEntry[] array = new BlogsEntryImpl[3];
3179    
3180                            array[0] = getByG_S_PrevAndNext(session, blogsEntry, groupId,
3181                                            status, orderByComparator, true);
3182    
3183                            array[1] = blogsEntry;
3184    
3185                            array[2] = getByG_S_PrevAndNext(session, blogsEntry, groupId,
3186                                            status, orderByComparator, false);
3187    
3188                            return array;
3189                    }
3190                    catch (Exception e) {
3191                            throw processException(e);
3192                    }
3193                    finally {
3194                            closeSession(session);
3195                    }
3196            }
3197    
3198            protected BlogsEntry getByG_S_PrevAndNext(Session session,
3199                    BlogsEntry blogsEntry, long groupId, int status,
3200                    OrderByComparator orderByComparator, boolean previous) {
3201                    StringBundler query = null;
3202    
3203                    if (orderByComparator != null) {
3204                            query = new StringBundler(6 +
3205                                            (orderByComparator.getOrderByFields().length * 6));
3206                    }
3207                    else {
3208                            query = new StringBundler(3);
3209                    }
3210    
3211                    query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
3212    
3213                    query.append(_FINDER_COLUMN_G_S_GROUPID_2);
3214    
3215                    query.append(_FINDER_COLUMN_G_S_STATUS_2);
3216    
3217                    if (orderByComparator != null) {
3218                            String[] orderByFields = orderByComparator.getOrderByFields();
3219    
3220                            if (orderByFields.length > 0) {
3221                                    query.append(WHERE_AND);
3222                            }
3223    
3224                            for (int i = 0; i < orderByFields.length; i++) {
3225                                    query.append(_ORDER_BY_ENTITY_ALIAS);
3226                                    query.append(orderByFields[i]);
3227    
3228                                    if ((i + 1) < orderByFields.length) {
3229                                            if (orderByComparator.isAscending() ^ previous) {
3230                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
3231                                            }
3232                                            else {
3233                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
3234                                            }
3235                                    }
3236                                    else {
3237                                            if (orderByComparator.isAscending() ^ previous) {
3238                                                    query.append(WHERE_GREATER_THAN);
3239                                            }
3240                                            else {
3241                                                    query.append(WHERE_LESSER_THAN);
3242                                            }
3243                                    }
3244                            }
3245    
3246                            query.append(ORDER_BY_CLAUSE);
3247    
3248                            for (int i = 0; i < orderByFields.length; i++) {
3249                                    query.append(_ORDER_BY_ENTITY_ALIAS);
3250                                    query.append(orderByFields[i]);
3251    
3252                                    if ((i + 1) < orderByFields.length) {
3253                                            if (orderByComparator.isAscending() ^ previous) {
3254                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
3255                                            }
3256                                            else {
3257                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
3258                                            }
3259                                    }
3260                                    else {
3261                                            if (orderByComparator.isAscending() ^ previous) {
3262                                                    query.append(ORDER_BY_ASC);
3263                                            }
3264                                            else {
3265                                                    query.append(ORDER_BY_DESC);
3266                                            }
3267                                    }
3268                            }
3269                    }
3270    
3271                    else {
3272                            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
3273                    }
3274    
3275                    String sql = query.toString();
3276    
3277                    Query q = session.createQuery(sql);
3278    
3279                    q.setFirstResult(0);
3280                    q.setMaxResults(2);
3281    
3282                    QueryPos qPos = QueryPos.getInstance(q);
3283    
3284                    qPos.add(groupId);
3285    
3286                    qPos.add(status);
3287    
3288                    if (orderByComparator != null) {
3289                            Object[] values = orderByComparator.getOrderByValues(blogsEntry);
3290    
3291                            for (Object value : values) {
3292                                    qPos.add(value);
3293                            }
3294                    }
3295    
3296                    List<BlogsEntry> list = q.list();
3297    
3298                    if (list.size() == 2) {
3299                            return list.get(1);
3300                    }
3301                    else {
3302                            return null;
3303                    }
3304            }
3305    
3306            public List<BlogsEntry> filterFindByG_S(long groupId, int status)
3307                    throws SystemException {
3308                    return filterFindByG_S(groupId, status, QueryUtil.ALL_POS,
3309                            QueryUtil.ALL_POS, null);
3310            }
3311    
3312            public List<BlogsEntry> filterFindByG_S(long groupId, int status,
3313                    int start, int end) throws SystemException {
3314                    return filterFindByG_S(groupId, status, start, end, null);
3315            }
3316    
3317            public List<BlogsEntry> filterFindByG_S(long groupId, int status,
3318                    int start, int end, OrderByComparator orderByComparator)
3319                    throws SystemException {
3320                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
3321                            return findByG_S(groupId, status, start, end, orderByComparator);
3322                    }
3323    
3324                    Session session = null;
3325    
3326                    try {
3327                            session = openSession();
3328    
3329                            StringBundler query = null;
3330    
3331                            if (orderByComparator != null) {
3332                                    query = new StringBundler(4 +
3333                                                    (orderByComparator.getOrderByFields().length * 3));
3334                            }
3335                            else {
3336                                    query = new StringBundler(4);
3337                            }
3338    
3339                            query.append(_FILTER_SQL_SELECT_BLOGSENTRY_WHERE);
3340    
3341                            query.append(_FINDER_COLUMN_G_S_GROUPID_2);
3342    
3343                            query.append(_FINDER_COLUMN_G_S_STATUS_2);
3344    
3345                            if (orderByComparator != null) {
3346                                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
3347                                            orderByComparator);
3348                            }
3349    
3350                            else {
3351                                    query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
3352                            }
3353    
3354                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
3355                                            BlogsEntry.class.getName(), _FILTER_COLUMN_PK,
3356                                            _FILTER_COLUMN_USERID, groupId);
3357    
3358                            SQLQuery q = session.createSQLQuery(sql);
3359    
3360                            q.addEntity(_FILTER_ENTITY_ALIAS, BlogsEntryImpl.class);
3361    
3362                            QueryPos qPos = QueryPos.getInstance(q);
3363    
3364                            qPos.add(groupId);
3365    
3366                            qPos.add(status);
3367    
3368                            return (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start, end);
3369                    }
3370                    catch (Exception e) {
3371                            throw processException(e);
3372                    }
3373                    finally {
3374                            closeSession(session);
3375                    }
3376            }
3377    
3378            public List<BlogsEntry> findByC_U_S(long companyId, long userId, int status)
3379                    throws SystemException {
3380                    return findByC_U_S(companyId, userId, status, QueryUtil.ALL_POS,
3381                            QueryUtil.ALL_POS, null);
3382            }
3383    
3384            public List<BlogsEntry> findByC_U_S(long companyId, long userId,
3385                    int status, int start, int end) throws SystemException {
3386                    return findByC_U_S(companyId, userId, status, start, end, null);
3387            }
3388    
3389            public List<BlogsEntry> findByC_U_S(long companyId, long userId,
3390                    int status, int start, int end, OrderByComparator orderByComparator)
3391                    throws SystemException {
3392                    Object[] finderArgs = new Object[] {
3393                                    companyId, userId, status,
3394                                    
3395                                    String.valueOf(start), String.valueOf(end),
3396                                    String.valueOf(orderByComparator)
3397                            };
3398    
3399                    List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_C_U_S,
3400                                    finderArgs, this);
3401    
3402                    if (list == null) {
3403                            Session session = null;
3404    
3405                            try {
3406                                    session = openSession();
3407    
3408                                    StringBundler query = null;
3409    
3410                                    if (orderByComparator != null) {
3411                                            query = new StringBundler(5 +
3412                                                            (orderByComparator.getOrderByFields().length * 3));
3413                                    }
3414                                    else {
3415                                            query = new StringBundler(5);
3416                                    }
3417    
3418                                    query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
3419    
3420                                    query.append(_FINDER_COLUMN_C_U_S_COMPANYID_2);
3421    
3422                                    query.append(_FINDER_COLUMN_C_U_S_USERID_2);
3423    
3424                                    query.append(_FINDER_COLUMN_C_U_S_STATUS_2);
3425    
3426                                    if (orderByComparator != null) {
3427                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
3428                                                    orderByComparator);
3429                                    }
3430    
3431                                    else {
3432                                            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
3433                                    }
3434    
3435                                    String sql = query.toString();
3436    
3437                                    Query q = session.createQuery(sql);
3438    
3439                                    QueryPos qPos = QueryPos.getInstance(q);
3440    
3441                                    qPos.add(companyId);
3442    
3443                                    qPos.add(userId);
3444    
3445                                    qPos.add(status);
3446    
3447                                    list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start,
3448                                                    end);
3449                            }
3450                            catch (Exception e) {
3451                                    throw processException(e);
3452                            }
3453                            finally {
3454                                    if (list == null) {
3455                                            list = new ArrayList<BlogsEntry>();
3456                                    }
3457    
3458                                    cacheResult(list);
3459    
3460                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_C_U_S,
3461                                            finderArgs, list);
3462    
3463                                    closeSession(session);
3464                            }
3465                    }
3466    
3467                    return list;
3468            }
3469    
3470            public BlogsEntry findByC_U_S_First(long companyId, long userId,
3471                    int status, OrderByComparator orderByComparator)
3472                    throws NoSuchEntryException, SystemException {
3473                    List<BlogsEntry> list = findByC_U_S(companyId, userId, status, 0, 1,
3474                                    orderByComparator);
3475    
3476                    if (list.isEmpty()) {
3477                            StringBundler msg = new StringBundler(8);
3478    
3479                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3480    
3481                            msg.append("companyId=");
3482                            msg.append(companyId);
3483    
3484                            msg.append(", userId=");
3485                            msg.append(userId);
3486    
3487                            msg.append(", status=");
3488                            msg.append(status);
3489    
3490                            msg.append(StringPool.CLOSE_CURLY_BRACE);
3491    
3492                            throw new NoSuchEntryException(msg.toString());
3493                    }
3494                    else {
3495                            return list.get(0);
3496                    }
3497            }
3498    
3499            public BlogsEntry findByC_U_S_Last(long companyId, long userId, int status,
3500                    OrderByComparator orderByComparator)
3501                    throws NoSuchEntryException, SystemException {
3502                    int count = countByC_U_S(companyId, userId, status);
3503    
3504                    List<BlogsEntry> list = findByC_U_S(companyId, userId, status,
3505                                    count - 1, count, orderByComparator);
3506    
3507                    if (list.isEmpty()) {
3508                            StringBundler msg = new StringBundler(8);
3509    
3510                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3511    
3512                            msg.append("companyId=");
3513                            msg.append(companyId);
3514    
3515                            msg.append(", userId=");
3516                            msg.append(userId);
3517    
3518                            msg.append(", status=");
3519                            msg.append(status);
3520    
3521                            msg.append(StringPool.CLOSE_CURLY_BRACE);
3522    
3523                            throw new NoSuchEntryException(msg.toString());
3524                    }
3525                    else {
3526                            return list.get(0);
3527                    }
3528            }
3529    
3530            public BlogsEntry[] findByC_U_S_PrevAndNext(long entryId, long companyId,
3531                    long userId, int status, OrderByComparator orderByComparator)
3532                    throws NoSuchEntryException, SystemException {
3533                    BlogsEntry blogsEntry = findByPrimaryKey(entryId);
3534    
3535                    Session session = null;
3536    
3537                    try {
3538                            session = openSession();
3539    
3540                            BlogsEntry[] array = new BlogsEntryImpl[3];
3541    
3542                            array[0] = getByC_U_S_PrevAndNext(session, blogsEntry, companyId,
3543                                            userId, status, orderByComparator, true);
3544    
3545                            array[1] = blogsEntry;
3546    
3547                            array[2] = getByC_U_S_PrevAndNext(session, blogsEntry, companyId,
3548                                            userId, status, orderByComparator, false);
3549    
3550                            return array;
3551                    }
3552                    catch (Exception e) {
3553                            throw processException(e);
3554                    }
3555                    finally {
3556                            closeSession(session);
3557                    }
3558            }
3559    
3560            protected BlogsEntry getByC_U_S_PrevAndNext(Session session,
3561                    BlogsEntry blogsEntry, long companyId, long userId, int status,
3562                    OrderByComparator orderByComparator, boolean previous) {
3563                    StringBundler query = null;
3564    
3565                    if (orderByComparator != null) {
3566                            query = new StringBundler(6 +
3567                                            (orderByComparator.getOrderByFields().length * 6));
3568                    }
3569                    else {
3570                            query = new StringBundler(3);
3571                    }
3572    
3573                    query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
3574    
3575                    query.append(_FINDER_COLUMN_C_U_S_COMPANYID_2);
3576    
3577                    query.append(_FINDER_COLUMN_C_U_S_USERID_2);
3578    
3579                    query.append(_FINDER_COLUMN_C_U_S_STATUS_2);
3580    
3581                    if (orderByComparator != null) {
3582                            String[] orderByFields = orderByComparator.getOrderByFields();
3583    
3584                            if (orderByFields.length > 0) {
3585                                    query.append(WHERE_AND);
3586                            }
3587    
3588                            for (int i = 0; i < orderByFields.length; i++) {
3589                                    query.append(_ORDER_BY_ENTITY_ALIAS);
3590                                    query.append(orderByFields[i]);
3591    
3592                                    if ((i + 1) < orderByFields.length) {
3593                                            if (orderByComparator.isAscending() ^ previous) {
3594                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
3595                                            }
3596                                            else {
3597                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
3598                                            }
3599                                    }
3600                                    else {
3601                                            if (orderByComparator.isAscending() ^ previous) {
3602                                                    query.append(WHERE_GREATER_THAN);
3603                                            }
3604                                            else {
3605                                                    query.append(WHERE_LESSER_THAN);
3606                                            }
3607                                    }
3608                            }
3609    
3610                            query.append(ORDER_BY_CLAUSE);
3611    
3612                            for (int i = 0; i < orderByFields.length; i++) {
3613                                    query.append(_ORDER_BY_ENTITY_ALIAS);
3614                                    query.append(orderByFields[i]);
3615    
3616                                    if ((i + 1) < orderByFields.length) {
3617                                            if (orderByComparator.isAscending() ^ previous) {
3618                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
3619                                            }
3620                                            else {
3621                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
3622                                            }
3623                                    }
3624                                    else {
3625                                            if (orderByComparator.isAscending() ^ previous) {
3626                                                    query.append(ORDER_BY_ASC);
3627                                            }
3628                                            else {
3629                                                    query.append(ORDER_BY_DESC);
3630                                            }
3631                                    }
3632                            }
3633                    }
3634    
3635                    else {
3636                            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
3637                    }
3638    
3639                    String sql = query.toString();
3640    
3641                    Query q = session.createQuery(sql);
3642    
3643                    q.setFirstResult(0);
3644                    q.setMaxResults(2);
3645    
3646                    QueryPos qPos = QueryPos.getInstance(q);
3647    
3648                    qPos.add(companyId);
3649    
3650                    qPos.add(userId);
3651    
3652                    qPos.add(status);
3653    
3654                    if (orderByComparator != null) {
3655                            Object[] values = orderByComparator.getOrderByValues(blogsEntry);
3656    
3657                            for (Object value : values) {
3658                                    qPos.add(value);
3659                            }
3660                    }
3661    
3662                    List<BlogsEntry> list = q.list();
3663    
3664                    if (list.size() == 2) {
3665                            return list.get(1);
3666                    }
3667                    else {
3668                            return null;
3669                    }
3670            }
3671    
3672            public List<BlogsEntry> findByC_LtD_S(long companyId, Date displayDate,
3673                    int status) throws SystemException {
3674                    return findByC_LtD_S(companyId, displayDate, status, QueryUtil.ALL_POS,
3675                            QueryUtil.ALL_POS, null);
3676            }
3677    
3678            public List<BlogsEntry> findByC_LtD_S(long companyId, Date displayDate,
3679                    int status, int start, int end) throws SystemException {
3680                    return findByC_LtD_S(companyId, displayDate, status, start, end, null);
3681            }
3682    
3683            public List<BlogsEntry> findByC_LtD_S(long companyId, Date displayDate,
3684                    int status, int start, int end, OrderByComparator orderByComparator)
3685                    throws SystemException {
3686                    Object[] finderArgs = new Object[] {
3687                                    companyId, displayDate, status,
3688                                    
3689                                    String.valueOf(start), String.valueOf(end),
3690                                    String.valueOf(orderByComparator)
3691                            };
3692    
3693                    List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_C_LTD_S,
3694                                    finderArgs, this);
3695    
3696                    if (list == null) {
3697                            Session session = null;
3698    
3699                            try {
3700                                    session = openSession();
3701    
3702                                    StringBundler query = null;
3703    
3704                                    if (orderByComparator != null) {
3705                                            query = new StringBundler(5 +
3706                                                            (orderByComparator.getOrderByFields().length * 3));
3707                                    }
3708                                    else {
3709                                            query = new StringBundler(5);
3710                                    }
3711    
3712                                    query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
3713    
3714                                    query.append(_FINDER_COLUMN_C_LTD_S_COMPANYID_2);
3715    
3716                                    if (displayDate == null) {
3717                                            query.append(_FINDER_COLUMN_C_LTD_S_DISPLAYDATE_1);
3718                                    }
3719                                    else {
3720                                            query.append(_FINDER_COLUMN_C_LTD_S_DISPLAYDATE_2);
3721                                    }
3722    
3723                                    query.append(_FINDER_COLUMN_C_LTD_S_STATUS_2);
3724    
3725                                    if (orderByComparator != null) {
3726                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
3727                                                    orderByComparator);
3728                                    }
3729    
3730                                    else {
3731                                            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
3732                                    }
3733    
3734                                    String sql = query.toString();
3735    
3736                                    Query q = session.createQuery(sql);
3737    
3738                                    QueryPos qPos = QueryPos.getInstance(q);
3739    
3740                                    qPos.add(companyId);
3741    
3742                                    if (displayDate != null) {
3743                                            qPos.add(CalendarUtil.getTimestamp(displayDate));
3744                                    }
3745    
3746                                    qPos.add(status);
3747    
3748                                    list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start,
3749                                                    end);
3750                            }
3751                            catch (Exception e) {
3752                                    throw processException(e);
3753                            }
3754                            finally {
3755                                    if (list == null) {
3756                                            list = new ArrayList<BlogsEntry>();
3757                                    }
3758    
3759                                    cacheResult(list);
3760    
3761                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_C_LTD_S,
3762                                            finderArgs, list);
3763    
3764                                    closeSession(session);
3765                            }
3766                    }
3767    
3768                    return list;
3769            }
3770    
3771            public BlogsEntry findByC_LtD_S_First(long companyId, Date displayDate,
3772                    int status, OrderByComparator orderByComparator)
3773                    throws NoSuchEntryException, SystemException {
3774                    List<BlogsEntry> list = findByC_LtD_S(companyId, displayDate, status,
3775                                    0, 1, orderByComparator);
3776    
3777                    if (list.isEmpty()) {
3778                            StringBundler msg = new StringBundler(8);
3779    
3780                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3781    
3782                            msg.append("companyId=");
3783                            msg.append(companyId);
3784    
3785                            msg.append(", displayDate=");
3786                            msg.append(displayDate);
3787    
3788                            msg.append(", status=");
3789                            msg.append(status);
3790    
3791                            msg.append(StringPool.CLOSE_CURLY_BRACE);
3792    
3793                            throw new NoSuchEntryException(msg.toString());
3794                    }
3795                    else {
3796                            return list.get(0);
3797                    }
3798            }
3799    
3800            public BlogsEntry findByC_LtD_S_Last(long companyId, Date displayDate,
3801                    int status, OrderByComparator orderByComparator)
3802                    throws NoSuchEntryException, SystemException {
3803                    int count = countByC_LtD_S(companyId, displayDate, status);
3804    
3805                    List<BlogsEntry> list = findByC_LtD_S(companyId, displayDate, status,
3806                                    count - 1, count, orderByComparator);
3807    
3808                    if (list.isEmpty()) {
3809                            StringBundler msg = new StringBundler(8);
3810    
3811                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
3812    
3813                            msg.append("companyId=");
3814                            msg.append(companyId);
3815    
3816                            msg.append(", displayDate=");
3817                            msg.append(displayDate);
3818    
3819                            msg.append(", status=");
3820                            msg.append(status);
3821    
3822                            msg.append(StringPool.CLOSE_CURLY_BRACE);
3823    
3824                            throw new NoSuchEntryException(msg.toString());
3825                    }
3826                    else {
3827                            return list.get(0);
3828                    }
3829            }
3830    
3831            public BlogsEntry[] findByC_LtD_S_PrevAndNext(long entryId, long companyId,
3832                    Date displayDate, int status, OrderByComparator orderByComparator)
3833                    throws NoSuchEntryException, SystemException {
3834                    BlogsEntry blogsEntry = findByPrimaryKey(entryId);
3835    
3836                    Session session = null;
3837    
3838                    try {
3839                            session = openSession();
3840    
3841                            BlogsEntry[] array = new BlogsEntryImpl[3];
3842    
3843                            array[0] = getByC_LtD_S_PrevAndNext(session, blogsEntry, companyId,
3844                                            displayDate, status, orderByComparator, true);
3845    
3846                            array[1] = blogsEntry;
3847    
3848                            array[2] = getByC_LtD_S_PrevAndNext(session, blogsEntry, companyId,
3849                                            displayDate, status, orderByComparator, false);
3850    
3851                            return array;
3852                    }
3853                    catch (Exception e) {
3854                            throw processException(e);
3855                    }
3856                    finally {
3857                            closeSession(session);
3858                    }
3859            }
3860    
3861            protected BlogsEntry getByC_LtD_S_PrevAndNext(Session session,
3862                    BlogsEntry blogsEntry, long companyId, Date displayDate, int status,
3863                    OrderByComparator orderByComparator, boolean previous) {
3864                    StringBundler query = null;
3865    
3866                    if (orderByComparator != null) {
3867                            query = new StringBundler(6 +
3868                                            (orderByComparator.getOrderByFields().length * 6));
3869                    }
3870                    else {
3871                            query = new StringBundler(3);
3872                    }
3873    
3874                    query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
3875    
3876                    query.append(_FINDER_COLUMN_C_LTD_S_COMPANYID_2);
3877    
3878                    if (displayDate == null) {
3879                            query.append(_FINDER_COLUMN_C_LTD_S_DISPLAYDATE_1);
3880                    }
3881                    else {
3882                            query.append(_FINDER_COLUMN_C_LTD_S_DISPLAYDATE_2);
3883                    }
3884    
3885                    query.append(_FINDER_COLUMN_C_LTD_S_STATUS_2);
3886    
3887                    if (orderByComparator != null) {
3888                            String[] orderByFields = orderByComparator.getOrderByFields();
3889    
3890                            if (orderByFields.length > 0) {
3891                                    query.append(WHERE_AND);
3892                            }
3893    
3894                            for (int i = 0; i < orderByFields.length; i++) {
3895                                    query.append(_ORDER_BY_ENTITY_ALIAS);
3896                                    query.append(orderByFields[i]);
3897    
3898                                    if ((i + 1) < orderByFields.length) {
3899                                            if (orderByComparator.isAscending() ^ previous) {
3900                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
3901                                            }
3902                                            else {
3903                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
3904                                            }
3905                                    }
3906                                    else {
3907                                            if (orderByComparator.isAscending() ^ previous) {
3908                                                    query.append(WHERE_GREATER_THAN);
3909                                            }
3910                                            else {
3911                                                    query.append(WHERE_LESSER_THAN);
3912                                            }
3913                                    }
3914                            }
3915    
3916                            query.append(ORDER_BY_CLAUSE);
3917    
3918                            for (int i = 0; i < orderByFields.length; i++) {
3919                                    query.append(_ORDER_BY_ENTITY_ALIAS);
3920                                    query.append(orderByFields[i]);
3921    
3922                                    if ((i + 1) < orderByFields.length) {
3923                                            if (orderByComparator.isAscending() ^ previous) {
3924                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
3925                                            }
3926                                            else {
3927                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
3928                                            }
3929                                    }
3930                                    else {
3931                                            if (orderByComparator.isAscending() ^ previous) {
3932                                                    query.append(ORDER_BY_ASC);
3933                                            }
3934                                            else {
3935                                                    query.append(ORDER_BY_DESC);
3936                                            }
3937                                    }
3938                            }
3939                    }
3940    
3941                    else {
3942                            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
3943                    }
3944    
3945                    String sql = query.toString();
3946    
3947                    Query q = session.createQuery(sql);
3948    
3949                    q.setFirstResult(0);
3950                    q.setMaxResults(2);
3951    
3952                    QueryPos qPos = QueryPos.getInstance(q);
3953    
3954                    qPos.add(companyId);
3955    
3956                    if (displayDate != null) {
3957                            qPos.add(CalendarUtil.getTimestamp(displayDate));
3958                    }
3959    
3960                    qPos.add(status);
3961    
3962                    if (orderByComparator != null) {
3963                            Object[] values = orderByComparator.getOrderByValues(blogsEntry);
3964    
3965                            for (Object value : values) {
3966                                    qPos.add(value);
3967                            }
3968                    }
3969    
3970                    List<BlogsEntry> list = q.list();
3971    
3972                    if (list.size() == 2) {
3973                            return list.get(1);
3974                    }
3975                    else {
3976                            return null;
3977                    }
3978            }
3979    
3980            public List<BlogsEntry> findByG_U_LtD(long groupId, long userId,
3981                    Date displayDate) throws SystemException {
3982                    return findByG_U_LtD(groupId, userId, displayDate, QueryUtil.ALL_POS,
3983                            QueryUtil.ALL_POS, null);
3984            }
3985    
3986            public List<BlogsEntry> findByG_U_LtD(long groupId, long userId,
3987                    Date displayDate, int start, int end) throws SystemException {
3988                    return findByG_U_LtD(groupId, userId, displayDate, start, end, null);
3989            }
3990    
3991            public List<BlogsEntry> findByG_U_LtD(long groupId, long userId,
3992                    Date displayDate, int start, int end,
3993                    OrderByComparator orderByComparator) throws SystemException {
3994                    Object[] finderArgs = new Object[] {
3995                                    groupId, userId, displayDate,
3996                                    
3997                                    String.valueOf(start), String.valueOf(end),
3998                                    String.valueOf(orderByComparator)
3999                            };
4000    
4001                    List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_U_LTD,
4002                                    finderArgs, this);
4003    
4004                    if (list == null) {
4005                            Session session = null;
4006    
4007                            try {
4008                                    session = openSession();
4009    
4010                                    StringBundler query = null;
4011    
4012                                    if (orderByComparator != null) {
4013                                            query = new StringBundler(5 +
4014                                                            (orderByComparator.getOrderByFields().length * 3));
4015                                    }
4016                                    else {
4017                                            query = new StringBundler(5);
4018                                    }
4019    
4020                                    query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
4021    
4022                                    query.append(_FINDER_COLUMN_G_U_LTD_GROUPID_2);
4023    
4024                                    query.append(_FINDER_COLUMN_G_U_LTD_USERID_2);
4025    
4026                                    if (displayDate == null) {
4027                                            query.append(_FINDER_COLUMN_G_U_LTD_DISPLAYDATE_1);
4028                                    }
4029                                    else {
4030                                            query.append(_FINDER_COLUMN_G_U_LTD_DISPLAYDATE_2);
4031                                    }
4032    
4033                                    if (orderByComparator != null) {
4034                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
4035                                                    orderByComparator);
4036                                    }
4037    
4038                                    else {
4039                                            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
4040                                    }
4041    
4042                                    String sql = query.toString();
4043    
4044                                    Query q = session.createQuery(sql);
4045    
4046                                    QueryPos qPos = QueryPos.getInstance(q);
4047    
4048                                    qPos.add(groupId);
4049    
4050                                    qPos.add(userId);
4051    
4052                                    if (displayDate != null) {
4053                                            qPos.add(CalendarUtil.getTimestamp(displayDate));
4054                                    }
4055    
4056                                    list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start,
4057                                                    end);
4058                            }
4059                            catch (Exception e) {
4060                                    throw processException(e);
4061                            }
4062                            finally {
4063                                    if (list == null) {
4064                                            list = new ArrayList<BlogsEntry>();
4065                                    }
4066    
4067                                    cacheResult(list);
4068    
4069                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_U_LTD,
4070                                            finderArgs, list);
4071    
4072                                    closeSession(session);
4073                            }
4074                    }
4075    
4076                    return list;
4077            }
4078    
4079            public BlogsEntry findByG_U_LtD_First(long groupId, long userId,
4080                    Date displayDate, OrderByComparator orderByComparator)
4081                    throws NoSuchEntryException, SystemException {
4082                    List<BlogsEntry> list = findByG_U_LtD(groupId, userId, displayDate, 0,
4083                                    1, orderByComparator);
4084    
4085                    if (list.isEmpty()) {
4086                            StringBundler msg = new StringBundler(8);
4087    
4088                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
4089    
4090                            msg.append("groupId=");
4091                            msg.append(groupId);
4092    
4093                            msg.append(", userId=");
4094                            msg.append(userId);
4095    
4096                            msg.append(", displayDate=");
4097                            msg.append(displayDate);
4098    
4099                            msg.append(StringPool.CLOSE_CURLY_BRACE);
4100    
4101                            throw new NoSuchEntryException(msg.toString());
4102                    }
4103                    else {
4104                            return list.get(0);
4105                    }
4106            }
4107    
4108            public BlogsEntry findByG_U_LtD_Last(long groupId, long userId,
4109                    Date displayDate, OrderByComparator orderByComparator)
4110                    throws NoSuchEntryException, SystemException {
4111                    int count = countByG_U_LtD(groupId, userId, displayDate);
4112    
4113                    List<BlogsEntry> list = findByG_U_LtD(groupId, userId, displayDate,
4114                                    count - 1, count, orderByComparator);
4115    
4116                    if (list.isEmpty()) {
4117                            StringBundler msg = new StringBundler(8);
4118    
4119                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
4120    
4121                            msg.append("groupId=");
4122                            msg.append(groupId);
4123    
4124                            msg.append(", userId=");
4125                            msg.append(userId);
4126    
4127                            msg.append(", displayDate=");
4128                            msg.append(displayDate);
4129    
4130                            msg.append(StringPool.CLOSE_CURLY_BRACE);
4131    
4132                            throw new NoSuchEntryException(msg.toString());
4133                    }
4134                    else {
4135                            return list.get(0);
4136                    }
4137            }
4138    
4139            public BlogsEntry[] findByG_U_LtD_PrevAndNext(long entryId, long groupId,
4140                    long userId, Date displayDate, OrderByComparator orderByComparator)
4141                    throws NoSuchEntryException, SystemException {
4142                    BlogsEntry blogsEntry = findByPrimaryKey(entryId);
4143    
4144                    Session session = null;
4145    
4146                    try {
4147                            session = openSession();
4148    
4149                            BlogsEntry[] array = new BlogsEntryImpl[3];
4150    
4151                            array[0] = getByG_U_LtD_PrevAndNext(session, blogsEntry, groupId,
4152                                            userId, displayDate, orderByComparator, true);
4153    
4154                            array[1] = blogsEntry;
4155    
4156                            array[2] = getByG_U_LtD_PrevAndNext(session, blogsEntry, groupId,
4157                                            userId, displayDate, orderByComparator, false);
4158    
4159                            return array;
4160                    }
4161                    catch (Exception e) {
4162                            throw processException(e);
4163                    }
4164                    finally {
4165                            closeSession(session);
4166                    }
4167            }
4168    
4169            protected BlogsEntry getByG_U_LtD_PrevAndNext(Session session,
4170                    BlogsEntry blogsEntry, long groupId, long userId, Date displayDate,
4171                    OrderByComparator orderByComparator, boolean previous) {
4172                    StringBundler query = null;
4173    
4174                    if (orderByComparator != null) {
4175                            query = new StringBundler(6 +
4176                                            (orderByComparator.getOrderByFields().length * 6));
4177                    }
4178                    else {
4179                            query = new StringBundler(3);
4180                    }
4181    
4182                    query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
4183    
4184                    query.append(_FINDER_COLUMN_G_U_LTD_GROUPID_2);
4185    
4186                    query.append(_FINDER_COLUMN_G_U_LTD_USERID_2);
4187    
4188                    if (displayDate == null) {
4189                            query.append(_FINDER_COLUMN_G_U_LTD_DISPLAYDATE_1);
4190                    }
4191                    else {
4192                            query.append(_FINDER_COLUMN_G_U_LTD_DISPLAYDATE_2);
4193                    }
4194    
4195                    if (orderByComparator != null) {
4196                            String[] orderByFields = orderByComparator.getOrderByFields();
4197    
4198                            if (orderByFields.length > 0) {
4199                                    query.append(WHERE_AND);
4200                            }
4201    
4202                            for (int i = 0; i < orderByFields.length; i++) {
4203                                    query.append(_ORDER_BY_ENTITY_ALIAS);
4204                                    query.append(orderByFields[i]);
4205    
4206                                    if ((i + 1) < orderByFields.length) {
4207                                            if (orderByComparator.isAscending() ^ previous) {
4208                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
4209                                            }
4210                                            else {
4211                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
4212                                            }
4213                                    }
4214                                    else {
4215                                            if (orderByComparator.isAscending() ^ previous) {
4216                                                    query.append(WHERE_GREATER_THAN);
4217                                            }
4218                                            else {
4219                                                    query.append(WHERE_LESSER_THAN);
4220                                            }
4221                                    }
4222                            }
4223    
4224                            query.append(ORDER_BY_CLAUSE);
4225    
4226                            for (int i = 0; i < orderByFields.length; i++) {
4227                                    query.append(_ORDER_BY_ENTITY_ALIAS);
4228                                    query.append(orderByFields[i]);
4229    
4230                                    if ((i + 1) < orderByFields.length) {
4231                                            if (orderByComparator.isAscending() ^ previous) {
4232                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
4233                                            }
4234                                            else {
4235                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
4236                                            }
4237                                    }
4238                                    else {
4239                                            if (orderByComparator.isAscending() ^ previous) {
4240                                                    query.append(ORDER_BY_ASC);
4241                                            }
4242                                            else {
4243                                                    query.append(ORDER_BY_DESC);
4244                                            }
4245                                    }
4246                            }
4247                    }
4248    
4249                    else {
4250                            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
4251                    }
4252    
4253                    String sql = query.toString();
4254    
4255                    Query q = session.createQuery(sql);
4256    
4257                    q.setFirstResult(0);
4258                    q.setMaxResults(2);
4259    
4260                    QueryPos qPos = QueryPos.getInstance(q);
4261    
4262                    qPos.add(groupId);
4263    
4264                    qPos.add(userId);
4265    
4266                    if (displayDate != null) {
4267                            qPos.add(CalendarUtil.getTimestamp(displayDate));
4268                    }
4269    
4270                    if (orderByComparator != null) {
4271                            Object[] values = orderByComparator.getOrderByValues(blogsEntry);
4272    
4273                            for (Object value : values) {
4274                                    qPos.add(value);
4275                            }
4276                    }
4277    
4278                    List<BlogsEntry> list = q.list();
4279    
4280                    if (list.size() == 2) {
4281                            return list.get(1);
4282                    }
4283                    else {
4284                            return null;
4285                    }
4286            }
4287    
4288            public List<BlogsEntry> filterFindByG_U_LtD(long groupId, long userId,
4289                    Date displayDate) throws SystemException {
4290                    return filterFindByG_U_LtD(groupId, userId, displayDate,
4291                            QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
4292            }
4293    
4294            public List<BlogsEntry> filterFindByG_U_LtD(long groupId, long userId,
4295                    Date displayDate, int start, int end) throws SystemException {
4296                    return filterFindByG_U_LtD(groupId, userId, displayDate, start, end,
4297                            null);
4298            }
4299    
4300            public List<BlogsEntry> filterFindByG_U_LtD(long groupId, long userId,
4301                    Date displayDate, int start, int end,
4302                    OrderByComparator orderByComparator) throws SystemException {
4303                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
4304                            return findByG_U_LtD(groupId, userId, displayDate, start, end,
4305                                    orderByComparator);
4306                    }
4307    
4308                    Session session = null;
4309    
4310                    try {
4311                            session = openSession();
4312    
4313                            StringBundler query = null;
4314    
4315                            if (orderByComparator != null) {
4316                                    query = new StringBundler(5 +
4317                                                    (orderByComparator.getOrderByFields().length * 3));
4318                            }
4319                            else {
4320                                    query = new StringBundler(5);
4321                            }
4322    
4323                            query.append(_FILTER_SQL_SELECT_BLOGSENTRY_WHERE);
4324    
4325                            query.append(_FINDER_COLUMN_G_U_LTD_GROUPID_2);
4326    
4327                            query.append(_FINDER_COLUMN_G_U_LTD_USERID_2);
4328    
4329                            if (displayDate == null) {
4330                                    query.append(_FINDER_COLUMN_G_U_LTD_DISPLAYDATE_1);
4331                            }
4332                            else {
4333                                    query.append(_FINDER_COLUMN_G_U_LTD_DISPLAYDATE_2);
4334                            }
4335    
4336                            if (orderByComparator != null) {
4337                                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
4338                                            orderByComparator);
4339                            }
4340    
4341                            else {
4342                                    query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
4343                            }
4344    
4345                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
4346                                            BlogsEntry.class.getName(), _FILTER_COLUMN_PK,
4347                                            _FILTER_COLUMN_USERID, groupId);
4348    
4349                            SQLQuery q = session.createSQLQuery(sql);
4350    
4351                            q.addEntity(_FILTER_ENTITY_ALIAS, BlogsEntryImpl.class);
4352    
4353                            QueryPos qPos = QueryPos.getInstance(q);
4354    
4355                            qPos.add(groupId);
4356    
4357                            qPos.add(userId);
4358    
4359                            if (displayDate != null) {
4360                                    qPos.add(CalendarUtil.getTimestamp(displayDate));
4361                            }
4362    
4363                            return (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start, end);
4364                    }
4365                    catch (Exception e) {
4366                            throw processException(e);
4367                    }
4368                    finally {
4369                            closeSession(session);
4370                    }
4371            }
4372    
4373            public List<BlogsEntry> findByG_U_S(long groupId, long userId, int status)
4374                    throws SystemException {
4375                    return findByG_U_S(groupId, userId, status, QueryUtil.ALL_POS,
4376                            QueryUtil.ALL_POS, null);
4377            }
4378    
4379            public List<BlogsEntry> findByG_U_S(long groupId, long userId, int status,
4380                    int start, int end) throws SystemException {
4381                    return findByG_U_S(groupId, userId, status, start, end, null);
4382            }
4383    
4384            public List<BlogsEntry> findByG_U_S(long groupId, long userId, int status,
4385                    int start, int end, OrderByComparator orderByComparator)
4386                    throws SystemException {
4387                    Object[] finderArgs = new Object[] {
4388                                    groupId, userId, status,
4389                                    
4390                                    String.valueOf(start), String.valueOf(end),
4391                                    String.valueOf(orderByComparator)
4392                            };
4393    
4394                    List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_U_S,
4395                                    finderArgs, this);
4396    
4397                    if (list == null) {
4398                            Session session = null;
4399    
4400                            try {
4401                                    session = openSession();
4402    
4403                                    StringBundler query = null;
4404    
4405                                    if (orderByComparator != null) {
4406                                            query = new StringBundler(5 +
4407                                                            (orderByComparator.getOrderByFields().length * 3));
4408                                    }
4409                                    else {
4410                                            query = new StringBundler(5);
4411                                    }
4412    
4413                                    query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
4414    
4415                                    query.append(_FINDER_COLUMN_G_U_S_GROUPID_2);
4416    
4417                                    query.append(_FINDER_COLUMN_G_U_S_USERID_2);
4418    
4419                                    query.append(_FINDER_COLUMN_G_U_S_STATUS_2);
4420    
4421                                    if (orderByComparator != null) {
4422                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
4423                                                    orderByComparator);
4424                                    }
4425    
4426                                    else {
4427                                            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
4428                                    }
4429    
4430                                    String sql = query.toString();
4431    
4432                                    Query q = session.createQuery(sql);
4433    
4434                                    QueryPos qPos = QueryPos.getInstance(q);
4435    
4436                                    qPos.add(groupId);
4437    
4438                                    qPos.add(userId);
4439    
4440                                    qPos.add(status);
4441    
4442                                    list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start,
4443                                                    end);
4444                            }
4445                            catch (Exception e) {
4446                                    throw processException(e);
4447                            }
4448                            finally {
4449                                    if (list == null) {
4450                                            list = new ArrayList<BlogsEntry>();
4451                                    }
4452    
4453                                    cacheResult(list);
4454    
4455                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_U_S,
4456                                            finderArgs, list);
4457    
4458                                    closeSession(session);
4459                            }
4460                    }
4461    
4462                    return list;
4463            }
4464    
4465            public BlogsEntry findByG_U_S_First(long groupId, long userId, int status,
4466                    OrderByComparator orderByComparator)
4467                    throws NoSuchEntryException, SystemException {
4468                    List<BlogsEntry> list = findByG_U_S(groupId, userId, status, 0, 1,
4469                                    orderByComparator);
4470    
4471                    if (list.isEmpty()) {
4472                            StringBundler msg = new StringBundler(8);
4473    
4474                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
4475    
4476                            msg.append("groupId=");
4477                            msg.append(groupId);
4478    
4479                            msg.append(", userId=");
4480                            msg.append(userId);
4481    
4482                            msg.append(", status=");
4483                            msg.append(status);
4484    
4485                            msg.append(StringPool.CLOSE_CURLY_BRACE);
4486    
4487                            throw new NoSuchEntryException(msg.toString());
4488                    }
4489                    else {
4490                            return list.get(0);
4491                    }
4492            }
4493    
4494            public BlogsEntry findByG_U_S_Last(long groupId, long userId, int status,
4495                    OrderByComparator orderByComparator)
4496                    throws NoSuchEntryException, SystemException {
4497                    int count = countByG_U_S(groupId, userId, status);
4498    
4499                    List<BlogsEntry> list = findByG_U_S(groupId, userId, status, count - 1,
4500                                    count, orderByComparator);
4501    
4502                    if (list.isEmpty()) {
4503                            StringBundler msg = new StringBundler(8);
4504    
4505                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
4506    
4507                            msg.append("groupId=");
4508                            msg.append(groupId);
4509    
4510                            msg.append(", userId=");
4511                            msg.append(userId);
4512    
4513                            msg.append(", status=");
4514                            msg.append(status);
4515    
4516                            msg.append(StringPool.CLOSE_CURLY_BRACE);
4517    
4518                            throw new NoSuchEntryException(msg.toString());
4519                    }
4520                    else {
4521                            return list.get(0);
4522                    }
4523            }
4524    
4525            public BlogsEntry[] findByG_U_S_PrevAndNext(long entryId, long groupId,
4526                    long userId, int status, OrderByComparator orderByComparator)
4527                    throws NoSuchEntryException, SystemException {
4528                    BlogsEntry blogsEntry = findByPrimaryKey(entryId);
4529    
4530                    Session session = null;
4531    
4532                    try {
4533                            session = openSession();
4534    
4535                            BlogsEntry[] array = new BlogsEntryImpl[3];
4536    
4537                            array[0] = getByG_U_S_PrevAndNext(session, blogsEntry, groupId,
4538                                            userId, status, orderByComparator, true);
4539    
4540                            array[1] = blogsEntry;
4541    
4542                            array[2] = getByG_U_S_PrevAndNext(session, blogsEntry, groupId,
4543                                            userId, status, orderByComparator, false);
4544    
4545                            return array;
4546                    }
4547                    catch (Exception e) {
4548                            throw processException(e);
4549                    }
4550                    finally {
4551                            closeSession(session);
4552                    }
4553            }
4554    
4555            protected BlogsEntry getByG_U_S_PrevAndNext(Session session,
4556                    BlogsEntry blogsEntry, long groupId, long userId, int status,
4557                    OrderByComparator orderByComparator, boolean previous) {
4558                    StringBundler query = null;
4559    
4560                    if (orderByComparator != null) {
4561                            query = new StringBundler(6 +
4562                                            (orderByComparator.getOrderByFields().length * 6));
4563                    }
4564                    else {
4565                            query = new StringBundler(3);
4566                    }
4567    
4568                    query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
4569    
4570                    query.append(_FINDER_COLUMN_G_U_S_GROUPID_2);
4571    
4572                    query.append(_FINDER_COLUMN_G_U_S_USERID_2);
4573    
4574                    query.append(_FINDER_COLUMN_G_U_S_STATUS_2);
4575    
4576                    if (orderByComparator != null) {
4577                            String[] orderByFields = orderByComparator.getOrderByFields();
4578    
4579                            if (orderByFields.length > 0) {
4580                                    query.append(WHERE_AND);
4581                            }
4582    
4583                            for (int i = 0; i < orderByFields.length; i++) {
4584                                    query.append(_ORDER_BY_ENTITY_ALIAS);
4585                                    query.append(orderByFields[i]);
4586    
4587                                    if ((i + 1) < orderByFields.length) {
4588                                            if (orderByComparator.isAscending() ^ previous) {
4589                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
4590                                            }
4591                                            else {
4592                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
4593                                            }
4594                                    }
4595                                    else {
4596                                            if (orderByComparator.isAscending() ^ previous) {
4597                                                    query.append(WHERE_GREATER_THAN);
4598                                            }
4599                                            else {
4600                                                    query.append(WHERE_LESSER_THAN);
4601                                            }
4602                                    }
4603                            }
4604    
4605                            query.append(ORDER_BY_CLAUSE);
4606    
4607                            for (int i = 0; i < orderByFields.length; i++) {
4608                                    query.append(_ORDER_BY_ENTITY_ALIAS);
4609                                    query.append(orderByFields[i]);
4610    
4611                                    if ((i + 1) < orderByFields.length) {
4612                                            if (orderByComparator.isAscending() ^ previous) {
4613                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
4614                                            }
4615                                            else {
4616                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
4617                                            }
4618                                    }
4619                                    else {
4620                                            if (orderByComparator.isAscending() ^ previous) {
4621                                                    query.append(ORDER_BY_ASC);
4622                                            }
4623                                            else {
4624                                                    query.append(ORDER_BY_DESC);
4625                                            }
4626                                    }
4627                            }
4628                    }
4629    
4630                    else {
4631                            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
4632                    }
4633    
4634                    String sql = query.toString();
4635    
4636                    Query q = session.createQuery(sql);
4637    
4638                    q.setFirstResult(0);
4639                    q.setMaxResults(2);
4640    
4641                    QueryPos qPos = QueryPos.getInstance(q);
4642    
4643                    qPos.add(groupId);
4644    
4645                    qPos.add(userId);
4646    
4647                    qPos.add(status);
4648    
4649                    if (orderByComparator != null) {
4650                            Object[] values = orderByComparator.getOrderByValues(blogsEntry);
4651    
4652                            for (Object value : values) {
4653                                    qPos.add(value);
4654                            }
4655                    }
4656    
4657                    List<BlogsEntry> list = q.list();
4658    
4659                    if (list.size() == 2) {
4660                            return list.get(1);
4661                    }
4662                    else {
4663                            return null;
4664                    }
4665            }
4666    
4667            public List<BlogsEntry> filterFindByG_U_S(long groupId, long userId,
4668                    int status) throws SystemException {
4669                    return filterFindByG_U_S(groupId, userId, status, QueryUtil.ALL_POS,
4670                            QueryUtil.ALL_POS, null);
4671            }
4672    
4673            public List<BlogsEntry> filterFindByG_U_S(long groupId, long userId,
4674                    int status, int start, int end) throws SystemException {
4675                    return filterFindByG_U_S(groupId, userId, status, start, end, null);
4676            }
4677    
4678            public List<BlogsEntry> filterFindByG_U_S(long groupId, long userId,
4679                    int status, int start, int end, OrderByComparator orderByComparator)
4680                    throws SystemException {
4681                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
4682                            return findByG_U_S(groupId, userId, status, start, end,
4683                                    orderByComparator);
4684                    }
4685    
4686                    Session session = null;
4687    
4688                    try {
4689                            session = openSession();
4690    
4691                            StringBundler query = null;
4692    
4693                            if (orderByComparator != null) {
4694                                    query = new StringBundler(5 +
4695                                                    (orderByComparator.getOrderByFields().length * 3));
4696                            }
4697                            else {
4698                                    query = new StringBundler(5);
4699                            }
4700    
4701                            query.append(_FILTER_SQL_SELECT_BLOGSENTRY_WHERE);
4702    
4703                            query.append(_FINDER_COLUMN_G_U_S_GROUPID_2);
4704    
4705                            query.append(_FINDER_COLUMN_G_U_S_USERID_2);
4706    
4707                            query.append(_FINDER_COLUMN_G_U_S_STATUS_2);
4708    
4709                            if (orderByComparator != null) {
4710                                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
4711                                            orderByComparator);
4712                            }
4713    
4714                            else {
4715                                    query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
4716                            }
4717    
4718                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
4719                                            BlogsEntry.class.getName(), _FILTER_COLUMN_PK,
4720                                            _FILTER_COLUMN_USERID, groupId);
4721    
4722                            SQLQuery q = session.createSQLQuery(sql);
4723    
4724                            q.addEntity(_FILTER_ENTITY_ALIAS, BlogsEntryImpl.class);
4725    
4726                            QueryPos qPos = QueryPos.getInstance(q);
4727    
4728                            qPos.add(groupId);
4729    
4730                            qPos.add(userId);
4731    
4732                            qPos.add(status);
4733    
4734                            return (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start, end);
4735                    }
4736                    catch (Exception e) {
4737                            throw processException(e);
4738                    }
4739                    finally {
4740                            closeSession(session);
4741                    }
4742            }
4743    
4744            public List<BlogsEntry> findByG_LtD_S(long groupId, Date displayDate,
4745                    int status) throws SystemException {
4746                    return findByG_LtD_S(groupId, displayDate, status, QueryUtil.ALL_POS,
4747                            QueryUtil.ALL_POS, null);
4748            }
4749    
4750            public List<BlogsEntry> findByG_LtD_S(long groupId, Date displayDate,
4751                    int status, int start, int end) throws SystemException {
4752                    return findByG_LtD_S(groupId, displayDate, status, start, end, null);
4753            }
4754    
4755            public List<BlogsEntry> findByG_LtD_S(long groupId, Date displayDate,
4756                    int status, int start, int end, OrderByComparator orderByComparator)
4757                    throws SystemException {
4758                    Object[] finderArgs = new Object[] {
4759                                    groupId, displayDate, status,
4760                                    
4761                                    String.valueOf(start), String.valueOf(end),
4762                                    String.valueOf(orderByComparator)
4763                            };
4764    
4765                    List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_LTD_S,
4766                                    finderArgs, this);
4767    
4768                    if (list == null) {
4769                            Session session = null;
4770    
4771                            try {
4772                                    session = openSession();
4773    
4774                                    StringBundler query = null;
4775    
4776                                    if (orderByComparator != null) {
4777                                            query = new StringBundler(5 +
4778                                                            (orderByComparator.getOrderByFields().length * 3));
4779                                    }
4780                                    else {
4781                                            query = new StringBundler(5);
4782                                    }
4783    
4784                                    query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
4785    
4786                                    query.append(_FINDER_COLUMN_G_LTD_S_GROUPID_2);
4787    
4788                                    if (displayDate == null) {
4789                                            query.append(_FINDER_COLUMN_G_LTD_S_DISPLAYDATE_1);
4790                                    }
4791                                    else {
4792                                            query.append(_FINDER_COLUMN_G_LTD_S_DISPLAYDATE_2);
4793                                    }
4794    
4795                                    query.append(_FINDER_COLUMN_G_LTD_S_STATUS_2);
4796    
4797                                    if (orderByComparator != null) {
4798                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
4799                                                    orderByComparator);
4800                                    }
4801    
4802                                    else {
4803                                            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
4804                                    }
4805    
4806                                    String sql = query.toString();
4807    
4808                                    Query q = session.createQuery(sql);
4809    
4810                                    QueryPos qPos = QueryPos.getInstance(q);
4811    
4812                                    qPos.add(groupId);
4813    
4814                                    if (displayDate != null) {
4815                                            qPos.add(CalendarUtil.getTimestamp(displayDate));
4816                                    }
4817    
4818                                    qPos.add(status);
4819    
4820                                    list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start,
4821                                                    end);
4822                            }
4823                            catch (Exception e) {
4824                                    throw processException(e);
4825                            }
4826                            finally {
4827                                    if (list == null) {
4828                                            list = new ArrayList<BlogsEntry>();
4829                                    }
4830    
4831                                    cacheResult(list);
4832    
4833                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_LTD_S,
4834                                            finderArgs, list);
4835    
4836                                    closeSession(session);
4837                            }
4838                    }
4839    
4840                    return list;
4841            }
4842    
4843            public BlogsEntry findByG_LtD_S_First(long groupId, Date displayDate,
4844                    int status, OrderByComparator orderByComparator)
4845                    throws NoSuchEntryException, SystemException {
4846                    List<BlogsEntry> list = findByG_LtD_S(groupId, displayDate, status, 0,
4847                                    1, orderByComparator);
4848    
4849                    if (list.isEmpty()) {
4850                            StringBundler msg = new StringBundler(8);
4851    
4852                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
4853    
4854                            msg.append("groupId=");
4855                            msg.append(groupId);
4856    
4857                            msg.append(", displayDate=");
4858                            msg.append(displayDate);
4859    
4860                            msg.append(", status=");
4861                            msg.append(status);
4862    
4863                            msg.append(StringPool.CLOSE_CURLY_BRACE);
4864    
4865                            throw new NoSuchEntryException(msg.toString());
4866                    }
4867                    else {
4868                            return list.get(0);
4869                    }
4870            }
4871    
4872            public BlogsEntry findByG_LtD_S_Last(long groupId, Date displayDate,
4873                    int status, OrderByComparator orderByComparator)
4874                    throws NoSuchEntryException, SystemException {
4875                    int count = countByG_LtD_S(groupId, displayDate, status);
4876    
4877                    List<BlogsEntry> list = findByG_LtD_S(groupId, displayDate, status,
4878                                    count - 1, count, orderByComparator);
4879    
4880                    if (list.isEmpty()) {
4881                            StringBundler msg = new StringBundler(8);
4882    
4883                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
4884    
4885                            msg.append("groupId=");
4886                            msg.append(groupId);
4887    
4888                            msg.append(", displayDate=");
4889                            msg.append(displayDate);
4890    
4891                            msg.append(", status=");
4892                            msg.append(status);
4893    
4894                            msg.append(StringPool.CLOSE_CURLY_BRACE);
4895    
4896                            throw new NoSuchEntryException(msg.toString());
4897                    }
4898                    else {
4899                            return list.get(0);
4900                    }
4901            }
4902    
4903            public BlogsEntry[] findByG_LtD_S_PrevAndNext(long entryId, long groupId,
4904                    Date displayDate, int status, OrderByComparator orderByComparator)
4905                    throws NoSuchEntryException, SystemException {
4906                    BlogsEntry blogsEntry = findByPrimaryKey(entryId);
4907    
4908                    Session session = null;
4909    
4910                    try {
4911                            session = openSession();
4912    
4913                            BlogsEntry[] array = new BlogsEntryImpl[3];
4914    
4915                            array[0] = getByG_LtD_S_PrevAndNext(session, blogsEntry, groupId,
4916                                            displayDate, status, orderByComparator, true);
4917    
4918                            array[1] = blogsEntry;
4919    
4920                            array[2] = getByG_LtD_S_PrevAndNext(session, blogsEntry, groupId,
4921                                            displayDate, status, orderByComparator, false);
4922    
4923                            return array;
4924                    }
4925                    catch (Exception e) {
4926                            throw processException(e);
4927                    }
4928                    finally {
4929                            closeSession(session);
4930                    }
4931            }
4932    
4933            protected BlogsEntry getByG_LtD_S_PrevAndNext(Session session,
4934                    BlogsEntry blogsEntry, long groupId, Date displayDate, int status,
4935                    OrderByComparator orderByComparator, boolean previous) {
4936                    StringBundler query = null;
4937    
4938                    if (orderByComparator != null) {
4939                            query = new StringBundler(6 +
4940                                            (orderByComparator.getOrderByFields().length * 6));
4941                    }
4942                    else {
4943                            query = new StringBundler(3);
4944                    }
4945    
4946                    query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
4947    
4948                    query.append(_FINDER_COLUMN_G_LTD_S_GROUPID_2);
4949    
4950                    if (displayDate == null) {
4951                            query.append(_FINDER_COLUMN_G_LTD_S_DISPLAYDATE_1);
4952                    }
4953                    else {
4954                            query.append(_FINDER_COLUMN_G_LTD_S_DISPLAYDATE_2);
4955                    }
4956    
4957                    query.append(_FINDER_COLUMN_G_LTD_S_STATUS_2);
4958    
4959                    if (orderByComparator != null) {
4960                            String[] orderByFields = orderByComparator.getOrderByFields();
4961    
4962                            if (orderByFields.length > 0) {
4963                                    query.append(WHERE_AND);
4964                            }
4965    
4966                            for (int i = 0; i < orderByFields.length; i++) {
4967                                    query.append(_ORDER_BY_ENTITY_ALIAS);
4968                                    query.append(orderByFields[i]);
4969    
4970                                    if ((i + 1) < orderByFields.length) {
4971                                            if (orderByComparator.isAscending() ^ previous) {
4972                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
4973                                            }
4974                                            else {
4975                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
4976                                            }
4977                                    }
4978                                    else {
4979                                            if (orderByComparator.isAscending() ^ previous) {
4980                                                    query.append(WHERE_GREATER_THAN);
4981                                            }
4982                                            else {
4983                                                    query.append(WHERE_LESSER_THAN);
4984                                            }
4985                                    }
4986                            }
4987    
4988                            query.append(ORDER_BY_CLAUSE);
4989    
4990                            for (int i = 0; i < orderByFields.length; i++) {
4991                                    query.append(_ORDER_BY_ENTITY_ALIAS);
4992                                    query.append(orderByFields[i]);
4993    
4994                                    if ((i + 1) < orderByFields.length) {
4995                                            if (orderByComparator.isAscending() ^ previous) {
4996                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
4997                                            }
4998                                            else {
4999                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
5000                                            }
5001                                    }
5002                                    else {
5003                                            if (orderByComparator.isAscending() ^ previous) {
5004                                                    query.append(ORDER_BY_ASC);
5005                                            }
5006                                            else {
5007                                                    query.append(ORDER_BY_DESC);
5008                                            }
5009                                    }
5010                            }
5011                    }
5012    
5013                    else {
5014                            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
5015                    }
5016    
5017                    String sql = query.toString();
5018    
5019                    Query q = session.createQuery(sql);
5020    
5021                    q.setFirstResult(0);
5022                    q.setMaxResults(2);
5023    
5024                    QueryPos qPos = QueryPos.getInstance(q);
5025    
5026                    qPos.add(groupId);
5027    
5028                    if (displayDate != null) {
5029                            qPos.add(CalendarUtil.getTimestamp(displayDate));
5030                    }
5031    
5032                    qPos.add(status);
5033    
5034                    if (orderByComparator != null) {
5035                            Object[] values = orderByComparator.getOrderByValues(blogsEntry);
5036    
5037                            for (Object value : values) {
5038                                    qPos.add(value);
5039                            }
5040                    }
5041    
5042                    List<BlogsEntry> list = q.list();
5043    
5044                    if (list.size() == 2) {
5045                            return list.get(1);
5046                    }
5047                    else {
5048                            return null;
5049                    }
5050            }
5051    
5052            public List<BlogsEntry> filterFindByG_LtD_S(long groupId, Date displayDate,
5053                    int status) throws SystemException {
5054                    return filterFindByG_LtD_S(groupId, displayDate, status,
5055                            QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
5056            }
5057    
5058            public List<BlogsEntry> filterFindByG_LtD_S(long groupId, Date displayDate,
5059                    int status, int start, int end) throws SystemException {
5060                    return filterFindByG_LtD_S(groupId, displayDate, status, start, end,
5061                            null);
5062            }
5063    
5064            public List<BlogsEntry> filterFindByG_LtD_S(long groupId, Date displayDate,
5065                    int status, int start, int end, OrderByComparator orderByComparator)
5066                    throws SystemException {
5067                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
5068                            return findByG_LtD_S(groupId, displayDate, status, start, end,
5069                                    orderByComparator);
5070                    }
5071    
5072                    Session session = null;
5073    
5074                    try {
5075                            session = openSession();
5076    
5077                            StringBundler query = null;
5078    
5079                            if (orderByComparator != null) {
5080                                    query = new StringBundler(5 +
5081                                                    (orderByComparator.getOrderByFields().length * 3));
5082                            }
5083                            else {
5084                                    query = new StringBundler(5);
5085                            }
5086    
5087                            query.append(_FILTER_SQL_SELECT_BLOGSENTRY_WHERE);
5088    
5089                            query.append(_FINDER_COLUMN_G_LTD_S_GROUPID_2);
5090    
5091                            if (displayDate == null) {
5092                                    query.append(_FINDER_COLUMN_G_LTD_S_DISPLAYDATE_1);
5093                            }
5094                            else {
5095                                    query.append(_FINDER_COLUMN_G_LTD_S_DISPLAYDATE_2);
5096                            }
5097    
5098                            query.append(_FINDER_COLUMN_G_LTD_S_STATUS_2);
5099    
5100                            if (orderByComparator != null) {
5101                                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
5102                                            orderByComparator);
5103                            }
5104    
5105                            else {
5106                                    query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
5107                            }
5108    
5109                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
5110                                            BlogsEntry.class.getName(), _FILTER_COLUMN_PK,
5111                                            _FILTER_COLUMN_USERID, groupId);
5112    
5113                            SQLQuery q = session.createSQLQuery(sql);
5114    
5115                            q.addEntity(_FILTER_ENTITY_ALIAS, BlogsEntryImpl.class);
5116    
5117                            QueryPos qPos = QueryPos.getInstance(q);
5118    
5119                            qPos.add(groupId);
5120    
5121                            if (displayDate != null) {
5122                                    qPos.add(CalendarUtil.getTimestamp(displayDate));
5123                            }
5124    
5125                            qPos.add(status);
5126    
5127                            return (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start, end);
5128                    }
5129                    catch (Exception e) {
5130                            throw processException(e);
5131                    }
5132                    finally {
5133                            closeSession(session);
5134                    }
5135            }
5136    
5137            public List<BlogsEntry> findByG_U_LtD_S(long groupId, long userId,
5138                    Date displayDate, int status) throws SystemException {
5139                    return findByG_U_LtD_S(groupId, userId, displayDate, status,
5140                            QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
5141            }
5142    
5143            public List<BlogsEntry> findByG_U_LtD_S(long groupId, long userId,
5144                    Date displayDate, int status, int start, int end)
5145                    throws SystemException {
5146                    return findByG_U_LtD_S(groupId, userId, displayDate, status, start,
5147                            end, null);
5148            }
5149    
5150            public List<BlogsEntry> findByG_U_LtD_S(long groupId, long userId,
5151                    Date displayDate, int status, int start, int end,
5152                    OrderByComparator orderByComparator) throws SystemException {
5153                    Object[] finderArgs = new Object[] {
5154                                    groupId, userId, displayDate, status,
5155                                    
5156                                    String.valueOf(start), String.valueOf(end),
5157                                    String.valueOf(orderByComparator)
5158                            };
5159    
5160                    List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_BY_G_U_LTD_S,
5161                                    finderArgs, this);
5162    
5163                    if (list == null) {
5164                            Session session = null;
5165    
5166                            try {
5167                                    session = openSession();
5168    
5169                                    StringBundler query = null;
5170    
5171                                    if (orderByComparator != null) {
5172                                            query = new StringBundler(6 +
5173                                                            (orderByComparator.getOrderByFields().length * 3));
5174                                    }
5175                                    else {
5176                                            query = new StringBundler(6);
5177                                    }
5178    
5179                                    query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
5180    
5181                                    query.append(_FINDER_COLUMN_G_U_LTD_S_GROUPID_2);
5182    
5183                                    query.append(_FINDER_COLUMN_G_U_LTD_S_USERID_2);
5184    
5185                                    if (displayDate == null) {
5186                                            query.append(_FINDER_COLUMN_G_U_LTD_S_DISPLAYDATE_1);
5187                                    }
5188                                    else {
5189                                            query.append(_FINDER_COLUMN_G_U_LTD_S_DISPLAYDATE_2);
5190                                    }
5191    
5192                                    query.append(_FINDER_COLUMN_G_U_LTD_S_STATUS_2);
5193    
5194                                    if (orderByComparator != null) {
5195                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
5196                                                    orderByComparator);
5197                                    }
5198    
5199                                    else {
5200                                            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
5201                                    }
5202    
5203                                    String sql = query.toString();
5204    
5205                                    Query q = session.createQuery(sql);
5206    
5207                                    QueryPos qPos = QueryPos.getInstance(q);
5208    
5209                                    qPos.add(groupId);
5210    
5211                                    qPos.add(userId);
5212    
5213                                    if (displayDate != null) {
5214                                            qPos.add(CalendarUtil.getTimestamp(displayDate));
5215                                    }
5216    
5217                                    qPos.add(status);
5218    
5219                                    list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start,
5220                                                    end);
5221                            }
5222                            catch (Exception e) {
5223                                    throw processException(e);
5224                            }
5225                            finally {
5226                                    if (list == null) {
5227                                            list = new ArrayList<BlogsEntry>();
5228                                    }
5229    
5230                                    cacheResult(list);
5231    
5232                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_BY_G_U_LTD_S,
5233                                            finderArgs, list);
5234    
5235                                    closeSession(session);
5236                            }
5237                    }
5238    
5239                    return list;
5240            }
5241    
5242            public BlogsEntry findByG_U_LtD_S_First(long groupId, long userId,
5243                    Date displayDate, int status, OrderByComparator orderByComparator)
5244                    throws NoSuchEntryException, SystemException {
5245                    List<BlogsEntry> list = findByG_U_LtD_S(groupId, userId, displayDate,
5246                                    status, 0, 1, orderByComparator);
5247    
5248                    if (list.isEmpty()) {
5249                            StringBundler msg = new StringBundler(10);
5250    
5251                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
5252    
5253                            msg.append("groupId=");
5254                            msg.append(groupId);
5255    
5256                            msg.append(", userId=");
5257                            msg.append(userId);
5258    
5259                            msg.append(", displayDate=");
5260                            msg.append(displayDate);
5261    
5262                            msg.append(", status=");
5263                            msg.append(status);
5264    
5265                            msg.append(StringPool.CLOSE_CURLY_BRACE);
5266    
5267                            throw new NoSuchEntryException(msg.toString());
5268                    }
5269                    else {
5270                            return list.get(0);
5271                    }
5272            }
5273    
5274            public BlogsEntry findByG_U_LtD_S_Last(long groupId, long userId,
5275                    Date displayDate, int status, OrderByComparator orderByComparator)
5276                    throws NoSuchEntryException, SystemException {
5277                    int count = countByG_U_LtD_S(groupId, userId, displayDate, status);
5278    
5279                    List<BlogsEntry> list = findByG_U_LtD_S(groupId, userId, displayDate,
5280                                    status, count - 1, count, orderByComparator);
5281    
5282                    if (list.isEmpty()) {
5283                            StringBundler msg = new StringBundler(10);
5284    
5285                            msg.append(_NO_SUCH_ENTITY_WITH_KEY);
5286    
5287                            msg.append("groupId=");
5288                            msg.append(groupId);
5289    
5290                            msg.append(", userId=");
5291                            msg.append(userId);
5292    
5293                            msg.append(", displayDate=");
5294                            msg.append(displayDate);
5295    
5296                            msg.append(", status=");
5297                            msg.append(status);
5298    
5299                            msg.append(StringPool.CLOSE_CURLY_BRACE);
5300    
5301                            throw new NoSuchEntryException(msg.toString());
5302                    }
5303                    else {
5304                            return list.get(0);
5305                    }
5306            }
5307    
5308            public BlogsEntry[] findByG_U_LtD_S_PrevAndNext(long entryId, long groupId,
5309                    long userId, Date displayDate, int status,
5310                    OrderByComparator orderByComparator)
5311                    throws NoSuchEntryException, SystemException {
5312                    BlogsEntry blogsEntry = findByPrimaryKey(entryId);
5313    
5314                    Session session = null;
5315    
5316                    try {
5317                            session = openSession();
5318    
5319                            BlogsEntry[] array = new BlogsEntryImpl[3];
5320    
5321                            array[0] = getByG_U_LtD_S_PrevAndNext(session, blogsEntry, groupId,
5322                                            userId, displayDate, status, orderByComparator, true);
5323    
5324                            array[1] = blogsEntry;
5325    
5326                            array[2] = getByG_U_LtD_S_PrevAndNext(session, blogsEntry, groupId,
5327                                            userId, displayDate, status, orderByComparator, false);
5328    
5329                            return array;
5330                    }
5331                    catch (Exception e) {
5332                            throw processException(e);
5333                    }
5334                    finally {
5335                            closeSession(session);
5336                    }
5337            }
5338    
5339            protected BlogsEntry getByG_U_LtD_S_PrevAndNext(Session session,
5340                    BlogsEntry blogsEntry, long groupId, long userId, Date displayDate,
5341                    int status, OrderByComparator orderByComparator, boolean previous) {
5342                    StringBundler query = null;
5343    
5344                    if (orderByComparator != null) {
5345                            query = new StringBundler(6 +
5346                                            (orderByComparator.getOrderByFields().length * 6));
5347                    }
5348                    else {
5349                            query = new StringBundler(3);
5350                    }
5351    
5352                    query.append(_SQL_SELECT_BLOGSENTRY_WHERE);
5353    
5354                    query.append(_FINDER_COLUMN_G_U_LTD_S_GROUPID_2);
5355    
5356                    query.append(_FINDER_COLUMN_G_U_LTD_S_USERID_2);
5357    
5358                    if (displayDate == null) {
5359                            query.append(_FINDER_COLUMN_G_U_LTD_S_DISPLAYDATE_1);
5360                    }
5361                    else {
5362                            query.append(_FINDER_COLUMN_G_U_LTD_S_DISPLAYDATE_2);
5363                    }
5364    
5365                    query.append(_FINDER_COLUMN_G_U_LTD_S_STATUS_2);
5366    
5367                    if (orderByComparator != null) {
5368                            String[] orderByFields = orderByComparator.getOrderByFields();
5369    
5370                            if (orderByFields.length > 0) {
5371                                    query.append(WHERE_AND);
5372                            }
5373    
5374                            for (int i = 0; i < orderByFields.length; i++) {
5375                                    query.append(_ORDER_BY_ENTITY_ALIAS);
5376                                    query.append(orderByFields[i]);
5377    
5378                                    if ((i + 1) < orderByFields.length) {
5379                                            if (orderByComparator.isAscending() ^ previous) {
5380                                                    query.append(WHERE_GREATER_THAN_HAS_NEXT);
5381                                            }
5382                                            else {
5383                                                    query.append(WHERE_LESSER_THAN_HAS_NEXT);
5384                                            }
5385                                    }
5386                                    else {
5387                                            if (orderByComparator.isAscending() ^ previous) {
5388                                                    query.append(WHERE_GREATER_THAN);
5389                                            }
5390                                            else {
5391                                                    query.append(WHERE_LESSER_THAN);
5392                                            }
5393                                    }
5394                            }
5395    
5396                            query.append(ORDER_BY_CLAUSE);
5397    
5398                            for (int i = 0; i < orderByFields.length; i++) {
5399                                    query.append(_ORDER_BY_ENTITY_ALIAS);
5400                                    query.append(orderByFields[i]);
5401    
5402                                    if ((i + 1) < orderByFields.length) {
5403                                            if (orderByComparator.isAscending() ^ previous) {
5404                                                    query.append(ORDER_BY_ASC_HAS_NEXT);
5405                                            }
5406                                            else {
5407                                                    query.append(ORDER_BY_DESC_HAS_NEXT);
5408                                            }
5409                                    }
5410                                    else {
5411                                            if (orderByComparator.isAscending() ^ previous) {
5412                                                    query.append(ORDER_BY_ASC);
5413                                            }
5414                                            else {
5415                                                    query.append(ORDER_BY_DESC);
5416                                            }
5417                                    }
5418                            }
5419                    }
5420    
5421                    else {
5422                            query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
5423                    }
5424    
5425                    String sql = query.toString();
5426    
5427                    Query q = session.createQuery(sql);
5428    
5429                    q.setFirstResult(0);
5430                    q.setMaxResults(2);
5431    
5432                    QueryPos qPos = QueryPos.getInstance(q);
5433    
5434                    qPos.add(groupId);
5435    
5436                    qPos.add(userId);
5437    
5438                    if (displayDate != null) {
5439                            qPos.add(CalendarUtil.getTimestamp(displayDate));
5440                    }
5441    
5442                    qPos.add(status);
5443    
5444                    if (orderByComparator != null) {
5445                            Object[] values = orderByComparator.getOrderByValues(blogsEntry);
5446    
5447                            for (Object value : values) {
5448                                    qPos.add(value);
5449                            }
5450                    }
5451    
5452                    List<BlogsEntry> list = q.list();
5453    
5454                    if (list.size() == 2) {
5455                            return list.get(1);
5456                    }
5457                    else {
5458                            return null;
5459                    }
5460            }
5461    
5462            public List<BlogsEntry> filterFindByG_U_LtD_S(long groupId, long userId,
5463                    Date displayDate, int status) throws SystemException {
5464                    return filterFindByG_U_LtD_S(groupId, userId, displayDate, status,
5465                            QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
5466            }
5467    
5468            public List<BlogsEntry> filterFindByG_U_LtD_S(long groupId, long userId,
5469                    Date displayDate, int status, int start, int end)
5470                    throws SystemException {
5471                    return filterFindByG_U_LtD_S(groupId, userId, displayDate, status,
5472                            start, end, null);
5473            }
5474    
5475            public List<BlogsEntry> filterFindByG_U_LtD_S(long groupId, long userId,
5476                    Date displayDate, int status, int start, int end,
5477                    OrderByComparator orderByComparator) throws SystemException {
5478                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
5479                            return findByG_U_LtD_S(groupId, userId, displayDate, status, start,
5480                                    end, orderByComparator);
5481                    }
5482    
5483                    Session session = null;
5484    
5485                    try {
5486                            session = openSession();
5487    
5488                            StringBundler query = null;
5489    
5490                            if (orderByComparator != null) {
5491                                    query = new StringBundler(6 +
5492                                                    (orderByComparator.getOrderByFields().length * 3));
5493                            }
5494                            else {
5495                                    query = new StringBundler(6);
5496                            }
5497    
5498                            query.append(_FILTER_SQL_SELECT_BLOGSENTRY_WHERE);
5499    
5500                            query.append(_FINDER_COLUMN_G_U_LTD_S_GROUPID_2);
5501    
5502                            query.append(_FINDER_COLUMN_G_U_LTD_S_USERID_2);
5503    
5504                            if (displayDate == null) {
5505                                    query.append(_FINDER_COLUMN_G_U_LTD_S_DISPLAYDATE_1);
5506                            }
5507                            else {
5508                                    query.append(_FINDER_COLUMN_G_U_LTD_S_DISPLAYDATE_2);
5509                            }
5510    
5511                            query.append(_FINDER_COLUMN_G_U_LTD_S_STATUS_2);
5512    
5513                            if (orderByComparator != null) {
5514                                    appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
5515                                            orderByComparator);
5516                            }
5517    
5518                            else {
5519                                    query.append(BlogsEntryModelImpl.ORDER_BY_JPQL);
5520                            }
5521    
5522                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
5523                                            BlogsEntry.class.getName(), _FILTER_COLUMN_PK,
5524                                            _FILTER_COLUMN_USERID, groupId);
5525    
5526                            SQLQuery q = session.createSQLQuery(sql);
5527    
5528                            q.addEntity(_FILTER_ENTITY_ALIAS, BlogsEntryImpl.class);
5529    
5530                            QueryPos qPos = QueryPos.getInstance(q);
5531    
5532                            qPos.add(groupId);
5533    
5534                            qPos.add(userId);
5535    
5536                            if (displayDate != null) {
5537                                    qPos.add(CalendarUtil.getTimestamp(displayDate));
5538                            }
5539    
5540                            qPos.add(status);
5541    
5542                            return (List<BlogsEntry>)QueryUtil.list(q, getDialect(), start, end);
5543                    }
5544                    catch (Exception e) {
5545                            throw processException(e);
5546                    }
5547                    finally {
5548                            closeSession(session);
5549                    }
5550            }
5551    
5552            public List<BlogsEntry> findAll() throws SystemException {
5553                    return findAll(QueryUtil.ALL_POS, QueryUtil.ALL_POS, null);
5554            }
5555    
5556            public List<BlogsEntry> findAll(int start, int end)
5557                    throws SystemException {
5558                    return findAll(start, end, null);
5559            }
5560    
5561            public List<BlogsEntry> findAll(int start, int end,
5562                    OrderByComparator orderByComparator) throws SystemException {
5563                    Object[] finderArgs = new Object[] {
5564                                    String.valueOf(start), String.valueOf(end),
5565                                    String.valueOf(orderByComparator)
5566                            };
5567    
5568                    List<BlogsEntry> list = (List<BlogsEntry>)FinderCacheUtil.getResult(FINDER_PATH_FIND_ALL,
5569                                    finderArgs, this);
5570    
5571                    if (list == null) {
5572                            Session session = null;
5573    
5574                            try {
5575                                    session = openSession();
5576    
5577                                    StringBundler query = null;
5578                                    String sql = null;
5579    
5580                                    if (orderByComparator != null) {
5581                                            query = new StringBundler(2 +
5582                                                            (orderByComparator.getOrderByFields().length * 3));
5583    
5584                                            query.append(_SQL_SELECT_BLOGSENTRY);
5585    
5586                                            appendOrderByComparator(query, _ORDER_BY_ENTITY_ALIAS,
5587                                                    orderByComparator);
5588    
5589                                            sql = query.toString();
5590                                    }
5591                                    else {
5592                                            sql = _SQL_SELECT_BLOGSENTRY.concat(BlogsEntryModelImpl.ORDER_BY_JPQL);
5593                                    }
5594    
5595                                    Query q = session.createQuery(sql);
5596    
5597                                    if (orderByComparator == null) {
5598                                            list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(),
5599                                                            start, end, false);
5600    
5601                                            Collections.sort(list);
5602                                    }
5603                                    else {
5604                                            list = (List<BlogsEntry>)QueryUtil.list(q, getDialect(),
5605                                                            start, end);
5606                                    }
5607                            }
5608                            catch (Exception e) {
5609                                    throw processException(e);
5610                            }
5611                            finally {
5612                                    if (list == null) {
5613                                            list = new ArrayList<BlogsEntry>();
5614                                    }
5615    
5616                                    cacheResult(list);
5617    
5618                                    FinderCacheUtil.putResult(FINDER_PATH_FIND_ALL, finderArgs, list);
5619    
5620                                    closeSession(session);
5621                            }
5622                    }
5623    
5624                    return list;
5625            }
5626    
5627            public void removeByUuid(String uuid) throws SystemException {
5628                    for (BlogsEntry blogsEntry : findByUuid(uuid)) {
5629                            remove(blogsEntry);
5630                    }
5631            }
5632    
5633            public void removeByUUID_G(String uuid, long groupId)
5634                    throws NoSuchEntryException, SystemException {
5635                    BlogsEntry blogsEntry = findByUUID_G(uuid, groupId);
5636    
5637                    remove(blogsEntry);
5638            }
5639    
5640            public void removeByGroupId(long groupId) throws SystemException {
5641                    for (BlogsEntry blogsEntry : findByGroupId(groupId)) {
5642                            remove(blogsEntry);
5643                    }
5644            }
5645    
5646            public void removeByCompanyId(long companyId) throws SystemException {
5647                    for (BlogsEntry blogsEntry : findByCompanyId(companyId)) {
5648                            remove(blogsEntry);
5649                    }
5650            }
5651    
5652            public void removeByC_U(long companyId, long userId)
5653                    throws SystemException {
5654                    for (BlogsEntry blogsEntry : findByC_U(companyId, userId)) {
5655                            remove(blogsEntry);
5656                    }
5657            }
5658    
5659            public void removeByC_LtD(long companyId, Date displayDate)
5660                    throws SystemException {
5661                    for (BlogsEntry blogsEntry : findByC_LtD(companyId, displayDate)) {
5662                            remove(blogsEntry);
5663                    }
5664            }
5665    
5666            public void removeByC_S(long companyId, int status)
5667                    throws SystemException {
5668                    for (BlogsEntry blogsEntry : findByC_S(companyId, status)) {
5669                            remove(blogsEntry);
5670                    }
5671            }
5672    
5673            public void removeByG_UT(long groupId, String urlTitle)
5674                    throws NoSuchEntryException, SystemException {
5675                    BlogsEntry blogsEntry = findByG_UT(groupId, urlTitle);
5676    
5677                    remove(blogsEntry);
5678            }
5679    
5680            public void removeByG_LtD(long groupId, Date displayDate)
5681                    throws SystemException {
5682                    for (BlogsEntry blogsEntry : findByG_LtD(groupId, displayDate)) {
5683                            remove(blogsEntry);
5684                    }
5685            }
5686    
5687            public void removeByG_S(long groupId, int status) throws SystemException {
5688                    for (BlogsEntry blogsEntry : findByG_S(groupId, status)) {
5689                            remove(blogsEntry);
5690                    }
5691            }
5692    
5693            public void removeByC_U_S(long companyId, long userId, int status)
5694                    throws SystemException {
5695                    for (BlogsEntry blogsEntry : findByC_U_S(companyId, userId, status)) {
5696                            remove(blogsEntry);
5697                    }
5698            }
5699    
5700            public void removeByC_LtD_S(long companyId, Date displayDate, int status)
5701                    throws SystemException {
5702                    for (BlogsEntry blogsEntry : findByC_LtD_S(companyId, displayDate,
5703                                    status)) {
5704                            remove(blogsEntry);
5705                    }
5706            }
5707    
5708            public void removeByG_U_LtD(long groupId, long userId, Date displayDate)
5709                    throws SystemException {
5710                    for (BlogsEntry blogsEntry : findByG_U_LtD(groupId, userId, displayDate)) {
5711                            remove(blogsEntry);
5712                    }
5713            }
5714    
5715            public void removeByG_U_S(long groupId, long userId, int status)
5716                    throws SystemException {
5717                    for (BlogsEntry blogsEntry : findByG_U_S(groupId, userId, status)) {
5718                            remove(blogsEntry);
5719                    }
5720            }
5721    
5722            public void removeByG_LtD_S(long groupId, Date displayDate, int status)
5723                    throws SystemException {
5724                    for (BlogsEntry blogsEntry : findByG_LtD_S(groupId, displayDate, status)) {
5725                            remove(blogsEntry);
5726                    }
5727            }
5728    
5729            public void removeByG_U_LtD_S(long groupId, long userId, Date displayDate,
5730                    int status) throws SystemException {
5731                    for (BlogsEntry blogsEntry : findByG_U_LtD_S(groupId, userId,
5732                                    displayDate, status)) {
5733                            remove(blogsEntry);
5734                    }
5735            }
5736    
5737            public void removeAll() throws SystemException {
5738                    for (BlogsEntry blogsEntry : findAll()) {
5739                            remove(blogsEntry);
5740                    }
5741            }
5742    
5743            public int countByUuid(String uuid) throws SystemException {
5744                    Object[] finderArgs = new Object[] { uuid };
5745    
5746                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_UUID,
5747                                    finderArgs, this);
5748    
5749                    if (count == null) {
5750                            Session session = null;
5751    
5752                            try {
5753                                    session = openSession();
5754    
5755                                    StringBundler query = new StringBundler(2);
5756    
5757                                    query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
5758    
5759                                    if (uuid == null) {
5760                                            query.append(_FINDER_COLUMN_UUID_UUID_1);
5761                                    }
5762                                    else {
5763                                            if (uuid.equals(StringPool.BLANK)) {
5764                                                    query.append(_FINDER_COLUMN_UUID_UUID_3);
5765                                            }
5766                                            else {
5767                                                    query.append(_FINDER_COLUMN_UUID_UUID_2);
5768                                            }
5769                                    }
5770    
5771                                    String sql = query.toString();
5772    
5773                                    Query q = session.createQuery(sql);
5774    
5775                                    QueryPos qPos = QueryPos.getInstance(q);
5776    
5777                                    if (uuid != null) {
5778                                            qPos.add(uuid);
5779                                    }
5780    
5781                                    count = (Long)q.uniqueResult();
5782                            }
5783                            catch (Exception e) {
5784                                    throw processException(e);
5785                            }
5786                            finally {
5787                                    if (count == null) {
5788                                            count = Long.valueOf(0);
5789                                    }
5790    
5791                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID,
5792                                            finderArgs, count);
5793    
5794                                    closeSession(session);
5795                            }
5796                    }
5797    
5798                    return count.intValue();
5799            }
5800    
5801            public int countByUUID_G(String uuid, long groupId)
5802                    throws SystemException {
5803                    Object[] finderArgs = new Object[] { uuid, groupId };
5804    
5805                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_UUID_G,
5806                                    finderArgs, this);
5807    
5808                    if (count == null) {
5809                            Session session = null;
5810    
5811                            try {
5812                                    session = openSession();
5813    
5814                                    StringBundler query = new StringBundler(3);
5815    
5816                                    query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
5817    
5818                                    if (uuid == null) {
5819                                            query.append(_FINDER_COLUMN_UUID_G_UUID_1);
5820                                    }
5821                                    else {
5822                                            if (uuid.equals(StringPool.BLANK)) {
5823                                                    query.append(_FINDER_COLUMN_UUID_G_UUID_3);
5824                                            }
5825                                            else {
5826                                                    query.append(_FINDER_COLUMN_UUID_G_UUID_2);
5827                                            }
5828                                    }
5829    
5830                                    query.append(_FINDER_COLUMN_UUID_G_GROUPID_2);
5831    
5832                                    String sql = query.toString();
5833    
5834                                    Query q = session.createQuery(sql);
5835    
5836                                    QueryPos qPos = QueryPos.getInstance(q);
5837    
5838                                    if (uuid != null) {
5839                                            qPos.add(uuid);
5840                                    }
5841    
5842                                    qPos.add(groupId);
5843    
5844                                    count = (Long)q.uniqueResult();
5845                            }
5846                            catch (Exception e) {
5847                                    throw processException(e);
5848                            }
5849                            finally {
5850                                    if (count == null) {
5851                                            count = Long.valueOf(0);
5852                                    }
5853    
5854                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_UUID_G,
5855                                            finderArgs, count);
5856    
5857                                    closeSession(session);
5858                            }
5859                    }
5860    
5861                    return count.intValue();
5862            }
5863    
5864            public int countByGroupId(long groupId) throws SystemException {
5865                    Object[] finderArgs = new Object[] { groupId };
5866    
5867                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_GROUPID,
5868                                    finderArgs, this);
5869    
5870                    if (count == null) {
5871                            Session session = null;
5872    
5873                            try {
5874                                    session = openSession();
5875    
5876                                    StringBundler query = new StringBundler(2);
5877    
5878                                    query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
5879    
5880                                    query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
5881    
5882                                    String sql = query.toString();
5883    
5884                                    Query q = session.createQuery(sql);
5885    
5886                                    QueryPos qPos = QueryPos.getInstance(q);
5887    
5888                                    qPos.add(groupId);
5889    
5890                                    count = (Long)q.uniqueResult();
5891                            }
5892                            catch (Exception e) {
5893                                    throw processException(e);
5894                            }
5895                            finally {
5896                                    if (count == null) {
5897                                            count = Long.valueOf(0);
5898                                    }
5899    
5900                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_GROUPID,
5901                                            finderArgs, count);
5902    
5903                                    closeSession(session);
5904                            }
5905                    }
5906    
5907                    return count.intValue();
5908            }
5909    
5910            public int filterCountByGroupId(long groupId) throws SystemException {
5911                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
5912                            return countByGroupId(groupId);
5913                    }
5914    
5915                    Session session = null;
5916    
5917                    try {
5918                            session = openSession();
5919    
5920                            StringBundler query = new StringBundler(2);
5921    
5922                            query.append(_FILTER_SQL_COUNT_BLOGSENTRY_WHERE);
5923    
5924                            query.append(_FINDER_COLUMN_GROUPID_GROUPID_2);
5925    
5926                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
5927                                            BlogsEntry.class.getName(), _FILTER_COLUMN_PK,
5928                                            _FILTER_COLUMN_USERID, groupId);
5929    
5930                            SQLQuery q = session.createSQLQuery(sql);
5931    
5932                            q.addScalar(COUNT_COLUMN_NAME,
5933                                    com.liferay.portal.kernel.dao.orm.Type.LONG);
5934    
5935                            QueryPos qPos = QueryPos.getInstance(q);
5936    
5937                            qPos.add(groupId);
5938    
5939                            Long count = (Long)q.uniqueResult();
5940    
5941                            return count.intValue();
5942                    }
5943                    catch (Exception e) {
5944                            throw processException(e);
5945                    }
5946                    finally {
5947                            closeSession(session);
5948                    }
5949            }
5950    
5951            public int countByCompanyId(long companyId) throws SystemException {
5952                    Object[] finderArgs = new Object[] { companyId };
5953    
5954                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_COMPANYID,
5955                                    finderArgs, this);
5956    
5957                    if (count == null) {
5958                            Session session = null;
5959    
5960                            try {
5961                                    session = openSession();
5962    
5963                                    StringBundler query = new StringBundler(2);
5964    
5965                                    query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
5966    
5967                                    query.append(_FINDER_COLUMN_COMPANYID_COMPANYID_2);
5968    
5969                                    String sql = query.toString();
5970    
5971                                    Query q = session.createQuery(sql);
5972    
5973                                    QueryPos qPos = QueryPos.getInstance(q);
5974    
5975                                    qPos.add(companyId);
5976    
5977                                    count = (Long)q.uniqueResult();
5978                            }
5979                            catch (Exception e) {
5980                                    throw processException(e);
5981                            }
5982                            finally {
5983                                    if (count == null) {
5984                                            count = Long.valueOf(0);
5985                                    }
5986    
5987                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_COMPANYID,
5988                                            finderArgs, count);
5989    
5990                                    closeSession(session);
5991                            }
5992                    }
5993    
5994                    return count.intValue();
5995            }
5996    
5997            public int countByC_U(long companyId, long userId)
5998                    throws SystemException {
5999                    Object[] finderArgs = new Object[] { companyId, userId };
6000    
6001                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_U,
6002                                    finderArgs, this);
6003    
6004                    if (count == null) {
6005                            Session session = null;
6006    
6007                            try {
6008                                    session = openSession();
6009    
6010                                    StringBundler query = new StringBundler(3);
6011    
6012                                    query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
6013    
6014                                    query.append(_FINDER_COLUMN_C_U_COMPANYID_2);
6015    
6016                                    query.append(_FINDER_COLUMN_C_U_USERID_2);
6017    
6018                                    String sql = query.toString();
6019    
6020                                    Query q = session.createQuery(sql);
6021    
6022                                    QueryPos qPos = QueryPos.getInstance(q);
6023    
6024                                    qPos.add(companyId);
6025    
6026                                    qPos.add(userId);
6027    
6028                                    count = (Long)q.uniqueResult();
6029                            }
6030                            catch (Exception e) {
6031                                    throw processException(e);
6032                            }
6033                            finally {
6034                                    if (count == null) {
6035                                            count = Long.valueOf(0);
6036                                    }
6037    
6038                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_U, finderArgs,
6039                                            count);
6040    
6041                                    closeSession(session);
6042                            }
6043                    }
6044    
6045                    return count.intValue();
6046            }
6047    
6048            public int countByC_LtD(long companyId, Date displayDate)
6049                    throws SystemException {
6050                    Object[] finderArgs = new Object[] { companyId, displayDate };
6051    
6052                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_LTD,
6053                                    finderArgs, this);
6054    
6055                    if (count == null) {
6056                            Session session = null;
6057    
6058                            try {
6059                                    session = openSession();
6060    
6061                                    StringBundler query = new StringBundler(3);
6062    
6063                                    query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
6064    
6065                                    query.append(_FINDER_COLUMN_C_LTD_COMPANYID_2);
6066    
6067                                    if (displayDate == null) {
6068                                            query.append(_FINDER_COLUMN_C_LTD_DISPLAYDATE_1);
6069                                    }
6070                                    else {
6071                                            query.append(_FINDER_COLUMN_C_LTD_DISPLAYDATE_2);
6072                                    }
6073    
6074                                    String sql = query.toString();
6075    
6076                                    Query q = session.createQuery(sql);
6077    
6078                                    QueryPos qPos = QueryPos.getInstance(q);
6079    
6080                                    qPos.add(companyId);
6081    
6082                                    if (displayDate != null) {
6083                                            qPos.add(CalendarUtil.getTimestamp(displayDate));
6084                                    }
6085    
6086                                    count = (Long)q.uniqueResult();
6087                            }
6088                            catch (Exception e) {
6089                                    throw processException(e);
6090                            }
6091                            finally {
6092                                    if (count == null) {
6093                                            count = Long.valueOf(0);
6094                                    }
6095    
6096                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_LTD,
6097                                            finderArgs, count);
6098    
6099                                    closeSession(session);
6100                            }
6101                    }
6102    
6103                    return count.intValue();
6104            }
6105    
6106            public int countByC_S(long companyId, int status) throws SystemException {
6107                    Object[] finderArgs = new Object[] { companyId, status };
6108    
6109                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_S,
6110                                    finderArgs, this);
6111    
6112                    if (count == null) {
6113                            Session session = null;
6114    
6115                            try {
6116                                    session = openSession();
6117    
6118                                    StringBundler query = new StringBundler(3);
6119    
6120                                    query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
6121    
6122                                    query.append(_FINDER_COLUMN_C_S_COMPANYID_2);
6123    
6124                                    query.append(_FINDER_COLUMN_C_S_STATUS_2);
6125    
6126                                    String sql = query.toString();
6127    
6128                                    Query q = session.createQuery(sql);
6129    
6130                                    QueryPos qPos = QueryPos.getInstance(q);
6131    
6132                                    qPos.add(companyId);
6133    
6134                                    qPos.add(status);
6135    
6136                                    count = (Long)q.uniqueResult();
6137                            }
6138                            catch (Exception e) {
6139                                    throw processException(e);
6140                            }
6141                            finally {
6142                                    if (count == null) {
6143                                            count = Long.valueOf(0);
6144                                    }
6145    
6146                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_S, finderArgs,
6147                                            count);
6148    
6149                                    closeSession(session);
6150                            }
6151                    }
6152    
6153                    return count.intValue();
6154            }
6155    
6156            public int countByG_UT(long groupId, String urlTitle)
6157                    throws SystemException {
6158                    Object[] finderArgs = new Object[] { groupId, urlTitle };
6159    
6160                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_UT,
6161                                    finderArgs, this);
6162    
6163                    if (count == null) {
6164                            Session session = null;
6165    
6166                            try {
6167                                    session = openSession();
6168    
6169                                    StringBundler query = new StringBundler(3);
6170    
6171                                    query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
6172    
6173                                    query.append(_FINDER_COLUMN_G_UT_GROUPID_2);
6174    
6175                                    if (urlTitle == null) {
6176                                            query.append(_FINDER_COLUMN_G_UT_URLTITLE_1);
6177                                    }
6178                                    else {
6179                                            if (urlTitle.equals(StringPool.BLANK)) {
6180                                                    query.append(_FINDER_COLUMN_G_UT_URLTITLE_3);
6181                                            }
6182                                            else {
6183                                                    query.append(_FINDER_COLUMN_G_UT_URLTITLE_2);
6184                                            }
6185                                    }
6186    
6187                                    String sql = query.toString();
6188    
6189                                    Query q = session.createQuery(sql);
6190    
6191                                    QueryPos qPos = QueryPos.getInstance(q);
6192    
6193                                    qPos.add(groupId);
6194    
6195                                    if (urlTitle != null) {
6196                                            qPos.add(urlTitle);
6197                                    }
6198    
6199                                    count = (Long)q.uniqueResult();
6200                            }
6201                            catch (Exception e) {
6202                                    throw processException(e);
6203                            }
6204                            finally {
6205                                    if (count == null) {
6206                                            count = Long.valueOf(0);
6207                                    }
6208    
6209                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_UT,
6210                                            finderArgs, count);
6211    
6212                                    closeSession(session);
6213                            }
6214                    }
6215    
6216                    return count.intValue();
6217            }
6218    
6219            public int filterCountByG_UT(long groupId, String urlTitle)
6220                    throws SystemException {
6221                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
6222                            return countByG_UT(groupId, urlTitle);
6223                    }
6224    
6225                    Session session = null;
6226    
6227                    try {
6228                            session = openSession();
6229    
6230                            StringBundler query = new StringBundler(3);
6231    
6232                            query.append(_FILTER_SQL_COUNT_BLOGSENTRY_WHERE);
6233    
6234                            query.append(_FINDER_COLUMN_G_UT_GROUPID_2);
6235    
6236                            if (urlTitle == null) {
6237                                    query.append(_FINDER_COLUMN_G_UT_URLTITLE_1);
6238                            }
6239                            else {
6240                                    if (urlTitle.equals(StringPool.BLANK)) {
6241                                            query.append(_FINDER_COLUMN_G_UT_URLTITLE_3);
6242                                    }
6243                                    else {
6244                                            query.append(_FINDER_COLUMN_G_UT_URLTITLE_2);
6245                                    }
6246                            }
6247    
6248                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
6249                                            BlogsEntry.class.getName(), _FILTER_COLUMN_PK,
6250                                            _FILTER_COLUMN_USERID, groupId);
6251    
6252                            SQLQuery q = session.createSQLQuery(sql);
6253    
6254                            q.addScalar(COUNT_COLUMN_NAME,
6255                                    com.liferay.portal.kernel.dao.orm.Type.LONG);
6256    
6257                            QueryPos qPos = QueryPos.getInstance(q);
6258    
6259                            qPos.add(groupId);
6260    
6261                            if (urlTitle != null) {
6262                                    qPos.add(urlTitle);
6263                            }
6264    
6265                            Long count = (Long)q.uniqueResult();
6266    
6267                            return count.intValue();
6268                    }
6269                    catch (Exception e) {
6270                            throw processException(e);
6271                    }
6272                    finally {
6273                            closeSession(session);
6274                    }
6275            }
6276    
6277            public int countByG_LtD(long groupId, Date displayDate)
6278                    throws SystemException {
6279                    Object[] finderArgs = new Object[] { groupId, displayDate };
6280    
6281                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_LTD,
6282                                    finderArgs, this);
6283    
6284                    if (count == null) {
6285                            Session session = null;
6286    
6287                            try {
6288                                    session = openSession();
6289    
6290                                    StringBundler query = new StringBundler(3);
6291    
6292                                    query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
6293    
6294                                    query.append(_FINDER_COLUMN_G_LTD_GROUPID_2);
6295    
6296                                    if (displayDate == null) {
6297                                            query.append(_FINDER_COLUMN_G_LTD_DISPLAYDATE_1);
6298                                    }
6299                                    else {
6300                                            query.append(_FINDER_COLUMN_G_LTD_DISPLAYDATE_2);
6301                                    }
6302    
6303                                    String sql = query.toString();
6304    
6305                                    Query q = session.createQuery(sql);
6306    
6307                                    QueryPos qPos = QueryPos.getInstance(q);
6308    
6309                                    qPos.add(groupId);
6310    
6311                                    if (displayDate != null) {
6312                                            qPos.add(CalendarUtil.getTimestamp(displayDate));
6313                                    }
6314    
6315                                    count = (Long)q.uniqueResult();
6316                            }
6317                            catch (Exception e) {
6318                                    throw processException(e);
6319                            }
6320                            finally {
6321                                    if (count == null) {
6322                                            count = Long.valueOf(0);
6323                                    }
6324    
6325                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_LTD,
6326                                            finderArgs, count);
6327    
6328                                    closeSession(session);
6329                            }
6330                    }
6331    
6332                    return count.intValue();
6333            }
6334    
6335            public int filterCountByG_LtD(long groupId, Date displayDate)
6336                    throws SystemException {
6337                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
6338                            return countByG_LtD(groupId, displayDate);
6339                    }
6340    
6341                    Session session = null;
6342    
6343                    try {
6344                            session = openSession();
6345    
6346                            StringBundler query = new StringBundler(3);
6347    
6348                            query.append(_FILTER_SQL_COUNT_BLOGSENTRY_WHERE);
6349    
6350                            query.append(_FINDER_COLUMN_G_LTD_GROUPID_2);
6351    
6352                            if (displayDate == null) {
6353                                    query.append(_FINDER_COLUMN_G_LTD_DISPLAYDATE_1);
6354                            }
6355                            else {
6356                                    query.append(_FINDER_COLUMN_G_LTD_DISPLAYDATE_2);
6357                            }
6358    
6359                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
6360                                            BlogsEntry.class.getName(), _FILTER_COLUMN_PK,
6361                                            _FILTER_COLUMN_USERID, groupId);
6362    
6363                            SQLQuery q = session.createSQLQuery(sql);
6364    
6365                            q.addScalar(COUNT_COLUMN_NAME,
6366                                    com.liferay.portal.kernel.dao.orm.Type.LONG);
6367    
6368                            QueryPos qPos = QueryPos.getInstance(q);
6369    
6370                            qPos.add(groupId);
6371    
6372                            if (displayDate != null) {
6373                                    qPos.add(CalendarUtil.getTimestamp(displayDate));
6374                            }
6375    
6376                            Long count = (Long)q.uniqueResult();
6377    
6378                            return count.intValue();
6379                    }
6380                    catch (Exception e) {
6381                            throw processException(e);
6382                    }
6383                    finally {
6384                            closeSession(session);
6385                    }
6386            }
6387    
6388            public int countByG_S(long groupId, int status) throws SystemException {
6389                    Object[] finderArgs = new Object[] { groupId, status };
6390    
6391                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_S,
6392                                    finderArgs, this);
6393    
6394                    if (count == null) {
6395                            Session session = null;
6396    
6397                            try {
6398                                    session = openSession();
6399    
6400                                    StringBundler query = new StringBundler(3);
6401    
6402                                    query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
6403    
6404                                    query.append(_FINDER_COLUMN_G_S_GROUPID_2);
6405    
6406                                    query.append(_FINDER_COLUMN_G_S_STATUS_2);
6407    
6408                                    String sql = query.toString();
6409    
6410                                    Query q = session.createQuery(sql);
6411    
6412                                    QueryPos qPos = QueryPos.getInstance(q);
6413    
6414                                    qPos.add(groupId);
6415    
6416                                    qPos.add(status);
6417    
6418                                    count = (Long)q.uniqueResult();
6419                            }
6420                            catch (Exception e) {
6421                                    throw processException(e);
6422                            }
6423                            finally {
6424                                    if (count == null) {
6425                                            count = Long.valueOf(0);
6426                                    }
6427    
6428                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_S, finderArgs,
6429                                            count);
6430    
6431                                    closeSession(session);
6432                            }
6433                    }
6434    
6435                    return count.intValue();
6436            }
6437    
6438            public int filterCountByG_S(long groupId, int status)
6439                    throws SystemException {
6440                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
6441                            return countByG_S(groupId, status);
6442                    }
6443    
6444                    Session session = null;
6445    
6446                    try {
6447                            session = openSession();
6448    
6449                            StringBundler query = new StringBundler(3);
6450    
6451                            query.append(_FILTER_SQL_COUNT_BLOGSENTRY_WHERE);
6452    
6453                            query.append(_FINDER_COLUMN_G_S_GROUPID_2);
6454    
6455                            query.append(_FINDER_COLUMN_G_S_STATUS_2);
6456    
6457                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
6458                                            BlogsEntry.class.getName(), _FILTER_COLUMN_PK,
6459                                            _FILTER_COLUMN_USERID, groupId);
6460    
6461                            SQLQuery q = session.createSQLQuery(sql);
6462    
6463                            q.addScalar(COUNT_COLUMN_NAME,
6464                                    com.liferay.portal.kernel.dao.orm.Type.LONG);
6465    
6466                            QueryPos qPos = QueryPos.getInstance(q);
6467    
6468                            qPos.add(groupId);
6469    
6470                            qPos.add(status);
6471    
6472                            Long count = (Long)q.uniqueResult();
6473    
6474                            return count.intValue();
6475                    }
6476                    catch (Exception e) {
6477                            throw processException(e);
6478                    }
6479                    finally {
6480                            closeSession(session);
6481                    }
6482            }
6483    
6484            public int countByC_U_S(long companyId, long userId, int status)
6485                    throws SystemException {
6486                    Object[] finderArgs = new Object[] { companyId, userId, status };
6487    
6488                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_U_S,
6489                                    finderArgs, this);
6490    
6491                    if (count == null) {
6492                            Session session = null;
6493    
6494                            try {
6495                                    session = openSession();
6496    
6497                                    StringBundler query = new StringBundler(4);
6498    
6499                                    query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
6500    
6501                                    query.append(_FINDER_COLUMN_C_U_S_COMPANYID_2);
6502    
6503                                    query.append(_FINDER_COLUMN_C_U_S_USERID_2);
6504    
6505                                    query.append(_FINDER_COLUMN_C_U_S_STATUS_2);
6506    
6507                                    String sql = query.toString();
6508    
6509                                    Query q = session.createQuery(sql);
6510    
6511                                    QueryPos qPos = QueryPos.getInstance(q);
6512    
6513                                    qPos.add(companyId);
6514    
6515                                    qPos.add(userId);
6516    
6517                                    qPos.add(status);
6518    
6519                                    count = (Long)q.uniqueResult();
6520                            }
6521                            catch (Exception e) {
6522                                    throw processException(e);
6523                            }
6524                            finally {
6525                                    if (count == null) {
6526                                            count = Long.valueOf(0);
6527                                    }
6528    
6529                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_U_S,
6530                                            finderArgs, count);
6531    
6532                                    closeSession(session);
6533                            }
6534                    }
6535    
6536                    return count.intValue();
6537            }
6538    
6539            public int countByC_LtD_S(long companyId, Date displayDate, int status)
6540                    throws SystemException {
6541                    Object[] finderArgs = new Object[] { companyId, displayDate, status };
6542    
6543                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_C_LTD_S,
6544                                    finderArgs, this);
6545    
6546                    if (count == null) {
6547                            Session session = null;
6548    
6549                            try {
6550                                    session = openSession();
6551    
6552                                    StringBundler query = new StringBundler(4);
6553    
6554                                    query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
6555    
6556                                    query.append(_FINDER_COLUMN_C_LTD_S_COMPANYID_2);
6557    
6558                                    if (displayDate == null) {
6559                                            query.append(_FINDER_COLUMN_C_LTD_S_DISPLAYDATE_1);
6560                                    }
6561                                    else {
6562                                            query.append(_FINDER_COLUMN_C_LTD_S_DISPLAYDATE_2);
6563                                    }
6564    
6565                                    query.append(_FINDER_COLUMN_C_LTD_S_STATUS_2);
6566    
6567                                    String sql = query.toString();
6568    
6569                                    Query q = session.createQuery(sql);
6570    
6571                                    QueryPos qPos = QueryPos.getInstance(q);
6572    
6573                                    qPos.add(companyId);
6574    
6575                                    if (displayDate != null) {
6576                                            qPos.add(CalendarUtil.getTimestamp(displayDate));
6577                                    }
6578    
6579                                    qPos.add(status);
6580    
6581                                    count = (Long)q.uniqueResult();
6582                            }
6583                            catch (Exception e) {
6584                                    throw processException(e);
6585                            }
6586                            finally {
6587                                    if (count == null) {
6588                                            count = Long.valueOf(0);
6589                                    }
6590    
6591                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_C_LTD_S,
6592                                            finderArgs, count);
6593    
6594                                    closeSession(session);
6595                            }
6596                    }
6597    
6598                    return count.intValue();
6599            }
6600    
6601            public int countByG_U_LtD(long groupId, long userId, Date displayDate)
6602                    throws SystemException {
6603                    Object[] finderArgs = new Object[] { groupId, userId, displayDate };
6604    
6605                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_U_LTD,
6606                                    finderArgs, this);
6607    
6608                    if (count == null) {
6609                            Session session = null;
6610    
6611                            try {
6612                                    session = openSession();
6613    
6614                                    StringBundler query = new StringBundler(4);
6615    
6616                                    query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
6617    
6618                                    query.append(_FINDER_COLUMN_G_U_LTD_GROUPID_2);
6619    
6620                                    query.append(_FINDER_COLUMN_G_U_LTD_USERID_2);
6621    
6622                                    if (displayDate == null) {
6623                                            query.append(_FINDER_COLUMN_G_U_LTD_DISPLAYDATE_1);
6624                                    }
6625                                    else {
6626                                            query.append(_FINDER_COLUMN_G_U_LTD_DISPLAYDATE_2);
6627                                    }
6628    
6629                                    String sql = query.toString();
6630    
6631                                    Query q = session.createQuery(sql);
6632    
6633                                    QueryPos qPos = QueryPos.getInstance(q);
6634    
6635                                    qPos.add(groupId);
6636    
6637                                    qPos.add(userId);
6638    
6639                                    if (displayDate != null) {
6640                                            qPos.add(CalendarUtil.getTimestamp(displayDate));
6641                                    }
6642    
6643                                    count = (Long)q.uniqueResult();
6644                            }
6645                            catch (Exception e) {
6646                                    throw processException(e);
6647                            }
6648                            finally {
6649                                    if (count == null) {
6650                                            count = Long.valueOf(0);
6651                                    }
6652    
6653                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_U_LTD,
6654                                            finderArgs, count);
6655    
6656                                    closeSession(session);
6657                            }
6658                    }
6659    
6660                    return count.intValue();
6661            }
6662    
6663            public int filterCountByG_U_LtD(long groupId, long userId, Date displayDate)
6664                    throws SystemException {
6665                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
6666                            return countByG_U_LtD(groupId, userId, displayDate);
6667                    }
6668    
6669                    Session session = null;
6670    
6671                    try {
6672                            session = openSession();
6673    
6674                            StringBundler query = new StringBundler(4);
6675    
6676                            query.append(_FILTER_SQL_COUNT_BLOGSENTRY_WHERE);
6677    
6678                            query.append(_FINDER_COLUMN_G_U_LTD_GROUPID_2);
6679    
6680                            query.append(_FINDER_COLUMN_G_U_LTD_USERID_2);
6681    
6682                            if (displayDate == null) {
6683                                    query.append(_FINDER_COLUMN_G_U_LTD_DISPLAYDATE_1);
6684                            }
6685                            else {
6686                                    query.append(_FINDER_COLUMN_G_U_LTD_DISPLAYDATE_2);
6687                            }
6688    
6689                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
6690                                            BlogsEntry.class.getName(), _FILTER_COLUMN_PK,
6691                                            _FILTER_COLUMN_USERID, groupId);
6692    
6693                            SQLQuery q = session.createSQLQuery(sql);
6694    
6695                            q.addScalar(COUNT_COLUMN_NAME,
6696                                    com.liferay.portal.kernel.dao.orm.Type.LONG);
6697    
6698                            QueryPos qPos = QueryPos.getInstance(q);
6699    
6700                            qPos.add(groupId);
6701    
6702                            qPos.add(userId);
6703    
6704                            if (displayDate != null) {
6705                                    qPos.add(CalendarUtil.getTimestamp(displayDate));
6706                            }
6707    
6708                            Long count = (Long)q.uniqueResult();
6709    
6710                            return count.intValue();
6711                    }
6712                    catch (Exception e) {
6713                            throw processException(e);
6714                    }
6715                    finally {
6716                            closeSession(session);
6717                    }
6718            }
6719    
6720            public int countByG_U_S(long groupId, long userId, int status)
6721                    throws SystemException {
6722                    Object[] finderArgs = new Object[] { groupId, userId, status };
6723    
6724                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_U_S,
6725                                    finderArgs, this);
6726    
6727                    if (count == null) {
6728                            Session session = null;
6729    
6730                            try {
6731                                    session = openSession();
6732    
6733                                    StringBundler query = new StringBundler(4);
6734    
6735                                    query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
6736    
6737                                    query.append(_FINDER_COLUMN_G_U_S_GROUPID_2);
6738    
6739                                    query.append(_FINDER_COLUMN_G_U_S_USERID_2);
6740    
6741                                    query.append(_FINDER_COLUMN_G_U_S_STATUS_2);
6742    
6743                                    String sql = query.toString();
6744    
6745                                    Query q = session.createQuery(sql);
6746    
6747                                    QueryPos qPos = QueryPos.getInstance(q);
6748    
6749                                    qPos.add(groupId);
6750    
6751                                    qPos.add(userId);
6752    
6753                                    qPos.add(status);
6754    
6755                                    count = (Long)q.uniqueResult();
6756                            }
6757                            catch (Exception e) {
6758                                    throw processException(e);
6759                            }
6760                            finally {
6761                                    if (count == null) {
6762                                            count = Long.valueOf(0);
6763                                    }
6764    
6765                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_U_S,
6766                                            finderArgs, count);
6767    
6768                                    closeSession(session);
6769                            }
6770                    }
6771    
6772                    return count.intValue();
6773            }
6774    
6775            public int filterCountByG_U_S(long groupId, long userId, int status)
6776                    throws SystemException {
6777                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
6778                            return countByG_U_S(groupId, userId, status);
6779                    }
6780    
6781                    Session session = null;
6782    
6783                    try {
6784                            session = openSession();
6785    
6786                            StringBundler query = new StringBundler(4);
6787    
6788                            query.append(_FILTER_SQL_COUNT_BLOGSENTRY_WHERE);
6789    
6790                            query.append(_FINDER_COLUMN_G_U_S_GROUPID_2);
6791    
6792                            query.append(_FINDER_COLUMN_G_U_S_USERID_2);
6793    
6794                            query.append(_FINDER_COLUMN_G_U_S_STATUS_2);
6795    
6796                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
6797                                            BlogsEntry.class.getName(), _FILTER_COLUMN_PK,
6798                                            _FILTER_COLUMN_USERID, groupId);
6799    
6800                            SQLQuery q = session.createSQLQuery(sql);
6801    
6802                            q.addScalar(COUNT_COLUMN_NAME,
6803                                    com.liferay.portal.kernel.dao.orm.Type.LONG);
6804    
6805                            QueryPos qPos = QueryPos.getInstance(q);
6806    
6807                            qPos.add(groupId);
6808    
6809                            qPos.add(userId);
6810    
6811                            qPos.add(status);
6812    
6813                            Long count = (Long)q.uniqueResult();
6814    
6815                            return count.intValue();
6816                    }
6817                    catch (Exception e) {
6818                            throw processException(e);
6819                    }
6820                    finally {
6821                            closeSession(session);
6822                    }
6823            }
6824    
6825            public int countByG_LtD_S(long groupId, Date displayDate, int status)
6826                    throws SystemException {
6827                    Object[] finderArgs = new Object[] { groupId, displayDate, status };
6828    
6829                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_LTD_S,
6830                                    finderArgs, this);
6831    
6832                    if (count == null) {
6833                            Session session = null;
6834    
6835                            try {
6836                                    session = openSession();
6837    
6838                                    StringBundler query = new StringBundler(4);
6839    
6840                                    query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
6841    
6842                                    query.append(_FINDER_COLUMN_G_LTD_S_GROUPID_2);
6843    
6844                                    if (displayDate == null) {
6845                                            query.append(_FINDER_COLUMN_G_LTD_S_DISPLAYDATE_1);
6846                                    }
6847                                    else {
6848                                            query.append(_FINDER_COLUMN_G_LTD_S_DISPLAYDATE_2);
6849                                    }
6850    
6851                                    query.append(_FINDER_COLUMN_G_LTD_S_STATUS_2);
6852    
6853                                    String sql = query.toString();
6854    
6855                                    Query q = session.createQuery(sql);
6856    
6857                                    QueryPos qPos = QueryPos.getInstance(q);
6858    
6859                                    qPos.add(groupId);
6860    
6861                                    if (displayDate != null) {
6862                                            qPos.add(CalendarUtil.getTimestamp(displayDate));
6863                                    }
6864    
6865                                    qPos.add(status);
6866    
6867                                    count = (Long)q.uniqueResult();
6868                            }
6869                            catch (Exception e) {
6870                                    throw processException(e);
6871                            }
6872                            finally {
6873                                    if (count == null) {
6874                                            count = Long.valueOf(0);
6875                                    }
6876    
6877                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_LTD_S,
6878                                            finderArgs, count);
6879    
6880                                    closeSession(session);
6881                            }
6882                    }
6883    
6884                    return count.intValue();
6885            }
6886    
6887            public int filterCountByG_LtD_S(long groupId, Date displayDate, int status)
6888                    throws SystemException {
6889                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
6890                            return countByG_LtD_S(groupId, displayDate, status);
6891                    }
6892    
6893                    Session session = null;
6894    
6895                    try {
6896                            session = openSession();
6897    
6898                            StringBundler query = new StringBundler(4);
6899    
6900                            query.append(_FILTER_SQL_COUNT_BLOGSENTRY_WHERE);
6901    
6902                            query.append(_FINDER_COLUMN_G_LTD_S_GROUPID_2);
6903    
6904                            if (displayDate == null) {
6905                                    query.append(_FINDER_COLUMN_G_LTD_S_DISPLAYDATE_1);
6906                            }
6907                            else {
6908                                    query.append(_FINDER_COLUMN_G_LTD_S_DISPLAYDATE_2);
6909                            }
6910    
6911                            query.append(_FINDER_COLUMN_G_LTD_S_STATUS_2);
6912    
6913                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
6914                                            BlogsEntry.class.getName(), _FILTER_COLUMN_PK,
6915                                            _FILTER_COLUMN_USERID, groupId);
6916    
6917                            SQLQuery q = session.createSQLQuery(sql);
6918    
6919                            q.addScalar(COUNT_COLUMN_NAME,
6920                                    com.liferay.portal.kernel.dao.orm.Type.LONG);
6921    
6922                            QueryPos qPos = QueryPos.getInstance(q);
6923    
6924                            qPos.add(groupId);
6925    
6926                            if (displayDate != null) {
6927                                    qPos.add(CalendarUtil.getTimestamp(displayDate));
6928                            }
6929    
6930                            qPos.add(status);
6931    
6932                            Long count = (Long)q.uniqueResult();
6933    
6934                            return count.intValue();
6935                    }
6936                    catch (Exception e) {
6937                            throw processException(e);
6938                    }
6939                    finally {
6940                            closeSession(session);
6941                    }
6942            }
6943    
6944            public int countByG_U_LtD_S(long groupId, long userId, Date displayDate,
6945                    int status) throws SystemException {
6946                    Object[] finderArgs = new Object[] { groupId, userId, displayDate, status };
6947    
6948                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_BY_G_U_LTD_S,
6949                                    finderArgs, this);
6950    
6951                    if (count == null) {
6952                            Session session = null;
6953    
6954                            try {
6955                                    session = openSession();
6956    
6957                                    StringBundler query = new StringBundler(5);
6958    
6959                                    query.append(_SQL_COUNT_BLOGSENTRY_WHERE);
6960    
6961                                    query.append(_FINDER_COLUMN_G_U_LTD_S_GROUPID_2);
6962    
6963                                    query.append(_FINDER_COLUMN_G_U_LTD_S_USERID_2);
6964    
6965                                    if (displayDate == null) {
6966                                            query.append(_FINDER_COLUMN_G_U_LTD_S_DISPLAYDATE_1);
6967                                    }
6968                                    else {
6969                                            query.append(_FINDER_COLUMN_G_U_LTD_S_DISPLAYDATE_2);
6970                                    }
6971    
6972                                    query.append(_FINDER_COLUMN_G_U_LTD_S_STATUS_2);
6973    
6974                                    String sql = query.toString();
6975    
6976                                    Query q = session.createQuery(sql);
6977    
6978                                    QueryPos qPos = QueryPos.getInstance(q);
6979    
6980                                    qPos.add(groupId);
6981    
6982                                    qPos.add(userId);
6983    
6984                                    if (displayDate != null) {
6985                                            qPos.add(CalendarUtil.getTimestamp(displayDate));
6986                                    }
6987    
6988                                    qPos.add(status);
6989    
6990                                    count = (Long)q.uniqueResult();
6991                            }
6992                            catch (Exception e) {
6993                                    throw processException(e);
6994                            }
6995                            finally {
6996                                    if (count == null) {
6997                                            count = Long.valueOf(0);
6998                                    }
6999    
7000                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_BY_G_U_LTD_S,
7001                                            finderArgs, count);
7002    
7003                                    closeSession(session);
7004                            }
7005                    }
7006    
7007                    return count.intValue();
7008            }
7009    
7010            public int filterCountByG_U_LtD_S(long groupId, long userId,
7011                    Date displayDate, int status) throws SystemException {
7012                    if (!InlineSQLHelperUtil.isEnabled(groupId)) {
7013                            return countByG_U_LtD_S(groupId, userId, displayDate, status);
7014                    }
7015    
7016                    Session session = null;
7017    
7018                    try {
7019                            session = openSession();
7020    
7021                            StringBundler query = new StringBundler(5);
7022    
7023                            query.append(_FILTER_SQL_COUNT_BLOGSENTRY_WHERE);
7024    
7025                            query.append(_FINDER_COLUMN_G_U_LTD_S_GROUPID_2);
7026    
7027                            query.append(_FINDER_COLUMN_G_U_LTD_S_USERID_2);
7028    
7029                            if (displayDate == null) {
7030                                    query.append(_FINDER_COLUMN_G_U_LTD_S_DISPLAYDATE_1);
7031                            }
7032                            else {
7033                                    query.append(_FINDER_COLUMN_G_U_LTD_S_DISPLAYDATE_2);
7034                            }
7035    
7036                            query.append(_FINDER_COLUMN_G_U_LTD_S_STATUS_2);
7037    
7038                            String sql = InlineSQLHelperUtil.replacePermissionCheck(query.toString(),
7039                                            BlogsEntry.class.getName(), _FILTER_COLUMN_PK,
7040                                            _FILTER_COLUMN_USERID, groupId);
7041    
7042                            SQLQuery q = session.createSQLQuery(sql);
7043    
7044                            q.addScalar(COUNT_COLUMN_NAME,
7045                                    com.liferay.portal.kernel.dao.orm.Type.LONG);
7046    
7047                            QueryPos qPos = QueryPos.getInstance(q);
7048    
7049                            qPos.add(groupId);
7050    
7051                            qPos.add(userId);
7052    
7053                            if (displayDate != null) {
7054                                    qPos.add(CalendarUtil.getTimestamp(displayDate));
7055                            }
7056    
7057                            qPos.add(status);
7058    
7059                            Long count = (Long)q.uniqueResult();
7060    
7061                            return count.intValue();
7062                    }
7063                    catch (Exception e) {
7064                            throw processException(e);
7065                    }
7066                    finally {
7067                            closeSession(session);
7068                    }
7069            }
7070    
7071            public int countAll() throws SystemException {
7072                    Object[] finderArgs = new Object[0];
7073    
7074                    Long count = (Long)FinderCacheUtil.getResult(FINDER_PATH_COUNT_ALL,
7075                                    finderArgs, this);
7076    
7077                    if (count == null) {
7078                            Session session = null;
7079    
7080                            try {
7081                                    session = openSession();
7082    
7083                                    Query q = session.createQuery(_SQL_COUNT_BLOGSENTRY);
7084    
7085                                    count = (Long)q.uniqueResult();
7086                            }
7087                            catch (Exception e) {
7088                                    throw processException(e);
7089                            }
7090                            finally {
7091                                    if (count == null) {
7092                                            count = Long.valueOf(0);
7093                                    }
7094    
7095                                    FinderCacheUtil.putResult(FINDER_PATH_COUNT_ALL, finderArgs,
7096                                            count);
7097    
7098                                    closeSession(session);
7099                            }
7100                    }
7101    
7102                    return count.intValue();
7103            }
7104    
7105            public void afterPropertiesSet() {
7106                    String[] listenerClassNames = StringUtil.split(GetterUtil.getString(
7107                                            com.liferay.portal.util.PropsUtil.get(
7108                                                    "value.object.listener.com.liferay.portlet.blogs.model.BlogsEntry")));
7109    
7110                    if (listenerClassNames.length > 0) {
7111                            try {
7112                                    List<ModelListener<BlogsEntry>> listenersList = new ArrayList<ModelListener<BlogsEntry>>();
7113    
7114                                    for (String listenerClassName : listenerClassNames) {
7115                                            listenersList.add((ModelListener<BlogsEntry>)InstanceFactory.newInstance(
7116                                                            listenerClassName));
7117                                    }
7118    
7119                                    listeners = listenersList.toArray(new ModelListener[listenersList.size()]);
7120                            }
7121                            catch (Exception e) {
7122                                    _log.error(e);
7123                            }
7124                    }
7125            }
7126    
7127            @BeanReference(type = BlogsEntryPersistence.class)
7128            protected BlogsEntryPersistence blogsEntryPersistence;
7129            @BeanReference(type = BlogsStatsUserPersistence.class)
7130            protected BlogsStatsUserPersistence blogsStatsUserPersistence;
7131            @BeanReference(type = CompanyPersistence.class)
7132            protected CompanyPersistence companyPersistence;
7133            @BeanReference(type = GroupPersistence.class)
7134            protected GroupPersistence groupPersistence;
7135            @BeanReference(type = OrganizationPersistence.class)
7136            protected OrganizationPersistence organizationPersistence;
7137            @BeanReference(type = PortletPreferencesPersistence.class)
7138            protected PortletPreferencesPersistence portletPreferencesPersistence;
7139            @BeanReference(type = ResourcePersistence.class)
7140            protected ResourcePersistence resourcePersistence;
7141            @BeanReference(type = UserPersistence.class)
7142            protected UserPersistence userPersistence;
7143            @BeanReference(type = WorkflowInstanceLinkPersistence.class)
7144            protected WorkflowInstanceLinkPersistence workflowInstanceLinkPersistence;
7145            @BeanReference(type = AssetEntryPersistence.class)
7146            protected AssetEntryPersistence assetEntryPersistence;
7147            @BeanReference(type = AssetTagPersistence.class)
7148            protected AssetTagPersistence assetTagPersistence;
7149            @BeanReference(type = ExpandoValuePersistence.class)
7150            protected ExpandoValuePersistence expandoValuePersistence;
7151            @BeanReference(type = MBMessagePersistence.class)
7152            protected MBMessagePersistence mbMessagePersistence;
7153            @BeanReference(type = RatingsStatsPersistence.class)
7154            protected RatingsStatsPersistence ratingsStatsPersistence;
7155            @BeanReference(type = SocialActivityPersistence.class)
7156            protected SocialActivityPersistence socialActivityPersistence;
7157            @BeanReference(type = SocialEquityLogPersistence.class)
7158            protected SocialEquityLogPersistence socialEquityLogPersistence;
7159            private static final String _SQL_SELECT_BLOGSENTRY = "SELECT blogsEntry FROM BlogsEntry blogsEntry";
7160            private static final String _SQL_SELECT_BLOGSENTRY_WHERE = "SELECT blogsEntry FROM BlogsEntry blogsEntry WHERE ";
7161            private static final String _SQL_COUNT_BLOGSENTRY = "SELECT COUNT(blogsEntry) FROM BlogsEntry blogsEntry";
7162            private static final String _SQL_COUNT_BLOGSENTRY_WHERE = "SELECT COUNT(blogsEntry) FROM BlogsEntry blogsEntry WHERE ";
7163            private static final String _FINDER_COLUMN_UUID_UUID_1 = "blogsEntry.uuid IS NULL";
7164            private static final String _FINDER_COLUMN_UUID_UUID_2 = "blogsEntry.uuid = ?";
7165            private static final String _FINDER_COLUMN_UUID_UUID_3 = "(blogsEntry.uuid IS NULL OR blogsEntry.uuid = ?)";
7166            private static final String _FINDER_COLUMN_UUID_G_UUID_1 = "blogsEntry.uuid IS NULL AND ";
7167            private static final String _FINDER_COLUMN_UUID_G_UUID_2 = "blogsEntry.uuid = ? AND ";
7168            private static final String _FINDER_COLUMN_UUID_G_UUID_3 = "(blogsEntry.uuid IS NULL OR blogsEntry.uuid = ?) AND ";
7169            private static final String _FINDER_COLUMN_UUID_G_GROUPID_2 = "blogsEntry.groupId = ?";
7170            private static final String _FINDER_COLUMN_GROUPID_GROUPID_2 = "blogsEntry.groupId = ?";
7171            private static final String _FINDER_COLUMN_COMPANYID_COMPANYID_2 = "blogsEntry.companyId = ?";
7172            private static final String _FINDER_COLUMN_C_U_COMPANYID_2 = "blogsEntry.companyId = ? AND ";
7173            private static final String _FINDER_COLUMN_C_U_USERID_2 = "blogsEntry.userId = ?";
7174            private static final String _FINDER_COLUMN_C_LTD_COMPANYID_2 = "blogsEntry.companyId = ? AND ";
7175            private static final String _FINDER_COLUMN_C_LTD_DISPLAYDATE_1 = "blogsEntry.displayDate < NULL";
7176            private static final String _FINDER_COLUMN_C_LTD_DISPLAYDATE_2 = "blogsEntry.displayDate < ?";
7177            private static final String _FINDER_COLUMN_C_S_COMPANYID_2 = "blogsEntry.companyId = ? AND ";
7178            private static final String _FINDER_COLUMN_C_S_STATUS_2 = "blogsEntry.status = ?";
7179            private static final String _FINDER_COLUMN_G_UT_GROUPID_2 = "blogsEntry.groupId = ? AND ";
7180            private static final String _FINDER_COLUMN_G_UT_URLTITLE_1 = "blogsEntry.urlTitle IS NULL";
7181            private static final String _FINDER_COLUMN_G_UT_URLTITLE_2 = "blogsEntry.urlTitle = ?";
7182            private static final String _FINDER_COLUMN_G_UT_URLTITLE_3 = "(blogsEntry.urlTitle IS NULL OR blogsEntry.urlTitle = ?)";
7183            private static final String _FINDER_COLUMN_G_LTD_GROUPID_2 = "blogsEntry.groupId = ? AND ";
7184            private static final String _FINDER_COLUMN_G_LTD_DISPLAYDATE_1 = "blogsEntry.displayDate < NULL";
7185            private static final String _FINDER_COLUMN_G_LTD_DISPLAYDATE_2 = "blogsEntry.displayDate < ?";
7186            private static final String _FINDER_COLUMN_G_S_GROUPID_2 = "blogsEntry.groupId = ? AND ";
7187            private static final String _FINDER_COLUMN_G_S_STATUS_2 = "blogsEntry.status = ?";
7188            private static final String _FINDER_COLUMN_C_U_S_COMPANYID_2 = "blogsEntry.companyId = ? AND ";
7189            private static final String _FINDER_COLUMN_C_U_S_USERID_2 = "blogsEntry.userId = ? AND ";
7190            private static final String _FINDER_COLUMN_C_U_S_STATUS_2 = "blogsEntry.status = ?";
7191            private static final String _FINDER_COLUMN_C_LTD_S_COMPANYID_2 = "blogsEntry.companyId = ? AND ";
7192            private static final String _FINDER_COLUMN_C_LTD_S_DISPLAYDATE_1 = "blogsEntry.displayDate < NULL AND ";
7193            private static final String _FINDER_COLUMN_C_LTD_S_DISPLAYDATE_2 = "blogsEntry.displayDate < ? AND ";
7194            private static final String _FINDER_COLUMN_C_LTD_S_STATUS_2 = "blogsEntry.status = ?";
7195            private static final String _FINDER_COLUMN_G_U_LTD_GROUPID_2 = "blogsEntry.groupId = ? AND ";
7196            private static final String _FINDER_COLUMN_G_U_LTD_USERID_2 = "blogsEntry.userId = ? AND ";
7197            private static final String _FINDER_COLUMN_G_U_LTD_DISPLAYDATE_1 = "blogsEntry.displayDate < NULL";
7198            private static final String _FINDER_COLUMN_G_U_LTD_DISPLAYDATE_2 = "blogsEntry.displayDate < ?";
7199            private static final String _FINDER_COLUMN_G_U_S_GROUPID_2 = "blogsEntry.groupId = ? AND ";
7200            private static final String _FINDER_COLUMN_G_U_S_USERID_2 = "blogsEntry.userId = ? AND ";
7201            private static final String _FINDER_COLUMN_G_U_S_STATUS_2 = "blogsEntry.status = ?";
7202            private static final String _FINDER_COLUMN_G_LTD_S_GROUPID_2 = "blogsEntry.groupId = ? AND ";
7203            private static final String _FINDER_COLUMN_G_LTD_S_DISPLAYDATE_1 = "blogsEntry.displayDate < NULL AND ";
7204            private static final String _FINDER_COLUMN_G_LTD_S_DISPLAYDATE_2 = "blogsEntry.displayDate < ? AND ";
7205            private static final String _FINDER_COLUMN_G_LTD_S_STATUS_2 = "blogsEntry.status = ?";
7206            private static final String _FINDER_COLUMN_G_U_LTD_S_GROUPID_2 = "blogsEntry.groupId = ? AND ";
7207            private static final String _FINDER_COLUMN_G_U_LTD_S_USERID_2 = "blogsEntry.userId = ? AND ";
7208            private static final String _FINDER_COLUMN_G_U_LTD_S_DISPLAYDATE_1 = "blogsEntry.displayDate < NULL AND ";
7209            private static final String _FINDER_COLUMN_G_U_LTD_S_DISPLAYDATE_2 = "blogsEntry.displayDate < ? AND ";
7210            private static final String _FINDER_COLUMN_G_U_LTD_S_STATUS_2 = "blogsEntry.status = ?";
7211            private static final String _FILTER_SQL_SELECT_BLOGSENTRY_WHERE = "SELECT DISTINCT {blogsEntry.*} FROM BlogsEntry blogsEntry WHERE ";
7212            private static final String _FILTER_SQL_COUNT_BLOGSENTRY_WHERE = "SELECT COUNT(DISTINCT blogsEntry.entryId) AS COUNT_VALUE FROM BlogsEntry blogsEntry WHERE ";
7213            private static final String _FILTER_COLUMN_PK = "blogsEntry.entryId";
7214            private static final String _FILTER_COLUMN_USERID = "blogsEntry.userId";
7215            private static final String _FILTER_ENTITY_ALIAS = "blogsEntry";
7216            private static final String _ORDER_BY_ENTITY_ALIAS = "blogsEntry.";
7217            private static final String _NO_SUCH_ENTITY_WITH_PRIMARY_KEY = "No BlogsEntry exists with the primary key ";
7218            private static final String _NO_SUCH_ENTITY_WITH_KEY = "No BlogsEntry exists with the key {";
7219            private static Log _log = LogFactoryUtil.getLog(BlogsEntryPersistenceImpl.class);
7220    }