001    /**
002     * Copyright (c) 2000-2012 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.blogs.service.persistence;
016    
017    import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil;
018    import com.liferay.portal.kernel.dao.orm.DynamicQuery;
019    import com.liferay.portal.kernel.exception.SystemException;
020    import com.liferay.portal.kernel.util.OrderByComparator;
021    import com.liferay.portal.kernel.util.ReferenceRegistry;
022    import com.liferay.portal.service.ServiceContext;
023    
024    import com.liferay.portlet.blogs.model.BlogsEntry;
025    
026    import java.util.List;
027    
028    /**
029     * The persistence utility for the blogs entry service. This utility wraps {@link BlogsEntryPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.
030     *
031     * <p>
032     * Caching information and settings can be found in <code>portal.properties</code>
033     * </p>
034     *
035     * @author Brian Wing Shun Chan
036     * @see BlogsEntryPersistence
037     * @see BlogsEntryPersistenceImpl
038     * @generated
039     */
040    public class BlogsEntryUtil {
041            /*
042             * NOTE FOR DEVELOPERS:
043             *
044             * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class.
045             */
046    
047            /**
048             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
049             */
050            public static void clearCache() {
051                    getPersistence().clearCache();
052            }
053    
054            /**
055             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
056             */
057            public static void clearCache(BlogsEntry blogsEntry) {
058                    getPersistence().clearCache(blogsEntry);
059            }
060    
061            /**
062             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
063             */
064            public long countWithDynamicQuery(DynamicQuery dynamicQuery)
065                    throws SystemException {
066                    return getPersistence().countWithDynamicQuery(dynamicQuery);
067            }
068    
069            /**
070             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
071             */
072            public static List<BlogsEntry> findWithDynamicQuery(
073                    DynamicQuery dynamicQuery) throws SystemException {
074                    return getPersistence().findWithDynamicQuery(dynamicQuery);
075            }
076    
077            /**
078             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
079             */
080            public static List<BlogsEntry> findWithDynamicQuery(
081                    DynamicQuery dynamicQuery, int start, int end)
082                    throws SystemException {
083                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
084            }
085    
086            /**
087             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
088             */
089            public static List<BlogsEntry> findWithDynamicQuery(
090                    DynamicQuery dynamicQuery, int start, int end,
091                    OrderByComparator orderByComparator) throws SystemException {
092                    return getPersistence()
093                                       .findWithDynamicQuery(dynamicQuery, start, end,
094                            orderByComparator);
095            }
096    
097            /**
098             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel)
099             */
100            public static BlogsEntry update(BlogsEntry blogsEntry)
101                    throws SystemException {
102                    return getPersistence().update(blogsEntry);
103            }
104    
105            /**
106             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext)
107             */
108            public static BlogsEntry update(BlogsEntry blogsEntry,
109                    ServiceContext serviceContext) throws SystemException {
110                    return getPersistence().update(blogsEntry, serviceContext);
111            }
112    
113            /**
114            * Caches the blogs entry in the entity cache if it is enabled.
115            *
116            * @param blogsEntry the blogs entry
117            */
118            public static void cacheResult(
119                    com.liferay.portlet.blogs.model.BlogsEntry blogsEntry) {
120                    getPersistence().cacheResult(blogsEntry);
121            }
122    
123            /**
124            * Caches the blogs entries in the entity cache if it is enabled.
125            *
126            * @param blogsEntries the blogs entries
127            */
128            public static void cacheResult(
129                    java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> blogsEntries) {
130                    getPersistence().cacheResult(blogsEntries);
131            }
132    
133            /**
134            * Creates a new blogs entry with the primary key. Does not add the blogs entry to the database.
135            *
136            * @param entryId the primary key for the new blogs entry
137            * @return the new blogs entry
138            */
139            public static com.liferay.portlet.blogs.model.BlogsEntry create(
140                    long entryId) {
141                    return getPersistence().create(entryId);
142            }
143    
144            /**
145            * Removes the blogs entry with the primary key from the database. Also notifies the appropriate model listeners.
146            *
147            * @param entryId the primary key of the blogs entry
148            * @return the blogs entry that was removed
149            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
150            * @throws SystemException if a system exception occurred
151            */
152            public static com.liferay.portlet.blogs.model.BlogsEntry remove(
153                    long entryId)
154                    throws com.liferay.portal.kernel.exception.SystemException,
155                            com.liferay.portlet.blogs.NoSuchEntryException {
156                    return getPersistence().remove(entryId);
157            }
158    
159            public static com.liferay.portlet.blogs.model.BlogsEntry updateImpl(
160                    com.liferay.portlet.blogs.model.BlogsEntry blogsEntry)
161                    throws com.liferay.portal.kernel.exception.SystemException {
162                    return getPersistence().updateImpl(blogsEntry);
163            }
164    
165            /**
166            * Returns the blogs entry with the primary key or throws a {@link com.liferay.portlet.blogs.NoSuchEntryException} if it could not be found.
167            *
168            * @param entryId the primary key of the blogs entry
169            * @return the blogs entry
170            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
171            * @throws SystemException if a system exception occurred
172            */
173            public static com.liferay.portlet.blogs.model.BlogsEntry findByPrimaryKey(
174                    long entryId)
175                    throws com.liferay.portal.kernel.exception.SystemException,
176                            com.liferay.portlet.blogs.NoSuchEntryException {
177                    return getPersistence().findByPrimaryKey(entryId);
178            }
179    
180            /**
181            * Returns the blogs entry with the primary key or returns <code>null</code> if it could not be found.
182            *
183            * @param entryId the primary key of the blogs entry
184            * @return the blogs entry, or <code>null</code> if a blogs entry with the primary key could not be found
185            * @throws SystemException if a system exception occurred
186            */
187            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByPrimaryKey(
188                    long entryId)
189                    throws com.liferay.portal.kernel.exception.SystemException {
190                    return getPersistence().fetchByPrimaryKey(entryId);
191            }
192    
193            /**
194            * Returns all the blogs entries where uuid = &#63;.
195            *
196            * @param uuid the uuid
197            * @return the matching blogs entries
198            * @throws SystemException if a system exception occurred
199            */
200            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByUuid(
201                    java.lang.String uuid)
202                    throws com.liferay.portal.kernel.exception.SystemException {
203                    return getPersistence().findByUuid(uuid);
204            }
205    
206            /**
207            * Returns a range of all the blogs entries where uuid = &#63;.
208            *
209            * <p>
210            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
211            * </p>
212            *
213            * @param uuid the uuid
214            * @param start the lower bound of the range of blogs entries
215            * @param end the upper bound of the range of blogs entries (not inclusive)
216            * @return the range of matching blogs entries
217            * @throws SystemException if a system exception occurred
218            */
219            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByUuid(
220                    java.lang.String uuid, int start, int end)
221                    throws com.liferay.portal.kernel.exception.SystemException {
222                    return getPersistence().findByUuid(uuid, start, end);
223            }
224    
225            /**
226            * Returns an ordered range of all the blogs entries where uuid = &#63;.
227            *
228            * <p>
229            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
230            * </p>
231            *
232            * @param uuid the uuid
233            * @param start the lower bound of the range of blogs entries
234            * @param end the upper bound of the range of blogs entries (not inclusive)
235            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
236            * @return the ordered range of matching blogs entries
237            * @throws SystemException if a system exception occurred
238            */
239            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByUuid(
240                    java.lang.String uuid, int start, int end,
241                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
242                    throws com.liferay.portal.kernel.exception.SystemException {
243                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
244            }
245    
246            /**
247            * Returns the first blogs entry in the ordered set where uuid = &#63;.
248            *
249            * @param uuid the uuid
250            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
251            * @return the first matching blogs entry
252            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
253            * @throws SystemException if a system exception occurred
254            */
255            public static com.liferay.portlet.blogs.model.BlogsEntry findByUuid_First(
256                    java.lang.String uuid,
257                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
258                    throws com.liferay.portal.kernel.exception.SystemException,
259                            com.liferay.portlet.blogs.NoSuchEntryException {
260                    return getPersistence().findByUuid_First(uuid, orderByComparator);
261            }
262    
263            /**
264            * Returns the first blogs entry in the ordered set where uuid = &#63;.
265            *
266            * @param uuid the uuid
267            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
268            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
269            * @throws SystemException if a system exception occurred
270            */
271            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByUuid_First(
272                    java.lang.String uuid,
273                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
274                    throws com.liferay.portal.kernel.exception.SystemException {
275                    return getPersistence().fetchByUuid_First(uuid, orderByComparator);
276            }
277    
278            /**
279            * Returns the last blogs entry in the ordered set where uuid = &#63;.
280            *
281            * @param uuid the uuid
282            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
283            * @return the last matching blogs entry
284            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
285            * @throws SystemException if a system exception occurred
286            */
287            public static com.liferay.portlet.blogs.model.BlogsEntry findByUuid_Last(
288                    java.lang.String uuid,
289                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
290                    throws com.liferay.portal.kernel.exception.SystemException,
291                            com.liferay.portlet.blogs.NoSuchEntryException {
292                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
293            }
294    
295            /**
296            * Returns the last blogs entry in the ordered set where uuid = &#63;.
297            *
298            * @param uuid the uuid
299            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
300            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
301            * @throws SystemException if a system exception occurred
302            */
303            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByUuid_Last(
304                    java.lang.String uuid,
305                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
306                    throws com.liferay.portal.kernel.exception.SystemException {
307                    return getPersistence().fetchByUuid_Last(uuid, orderByComparator);
308            }
309    
310            /**
311            * Returns the blogs entries before and after the current blogs entry in the ordered set where uuid = &#63;.
312            *
313            * @param entryId the primary key of the current blogs entry
314            * @param uuid the uuid
315            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
316            * @return the previous, current, and next blogs entry
317            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
318            * @throws SystemException if a system exception occurred
319            */
320            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByUuid_PrevAndNext(
321                    long entryId, java.lang.String uuid,
322                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
323                    throws com.liferay.portal.kernel.exception.SystemException,
324                            com.liferay.portlet.blogs.NoSuchEntryException {
325                    return getPersistence()
326                                       .findByUuid_PrevAndNext(entryId, uuid, orderByComparator);
327            }
328    
329            /**
330            * Returns the blogs entry where uuid = &#63; and groupId = &#63; or throws a {@link com.liferay.portlet.blogs.NoSuchEntryException} if it could not be found.
331            *
332            * @param uuid the uuid
333            * @param groupId the group ID
334            * @return the matching blogs entry
335            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
336            * @throws SystemException if a system exception occurred
337            */
338            public static com.liferay.portlet.blogs.model.BlogsEntry findByUUID_G(
339                    java.lang.String uuid, long groupId)
340                    throws com.liferay.portal.kernel.exception.SystemException,
341                            com.liferay.portlet.blogs.NoSuchEntryException {
342                    return getPersistence().findByUUID_G(uuid, groupId);
343            }
344    
345            /**
346            * Returns the blogs entry where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
347            *
348            * @param uuid the uuid
349            * @param groupId the group ID
350            * @return the matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
351            * @throws SystemException if a system exception occurred
352            */
353            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByUUID_G(
354                    java.lang.String uuid, long groupId)
355                    throws com.liferay.portal.kernel.exception.SystemException {
356                    return getPersistence().fetchByUUID_G(uuid, groupId);
357            }
358    
359            /**
360            * Returns the blogs entry where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
361            *
362            * @param uuid the uuid
363            * @param groupId the group ID
364            * @param retrieveFromCache whether to use the finder cache
365            * @return the matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
366            * @throws SystemException if a system exception occurred
367            */
368            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByUUID_G(
369                    java.lang.String uuid, long groupId, boolean retrieveFromCache)
370                    throws com.liferay.portal.kernel.exception.SystemException {
371                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
372            }
373    
374            /**
375            * Returns all the blogs entries where uuid = &#63; and companyId = &#63;.
376            *
377            * @param uuid the uuid
378            * @param companyId the company ID
379            * @return the matching blogs entries
380            * @throws SystemException if a system exception occurred
381            */
382            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByUuid_C(
383                    java.lang.String uuid, long companyId)
384                    throws com.liferay.portal.kernel.exception.SystemException {
385                    return getPersistence().findByUuid_C(uuid, companyId);
386            }
387    
388            /**
389            * Returns a range of all the blogs entries where uuid = &#63; and companyId = &#63;.
390            *
391            * <p>
392            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
393            * </p>
394            *
395            * @param uuid the uuid
396            * @param companyId the company ID
397            * @param start the lower bound of the range of blogs entries
398            * @param end the upper bound of the range of blogs entries (not inclusive)
399            * @return the range of matching blogs entries
400            * @throws SystemException if a system exception occurred
401            */
402            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByUuid_C(
403                    java.lang.String uuid, long companyId, int start, int end)
404                    throws com.liferay.portal.kernel.exception.SystemException {
405                    return getPersistence().findByUuid_C(uuid, companyId, start, end);
406            }
407    
408            /**
409            * Returns an ordered range of all the blogs entries where uuid = &#63; and companyId = &#63;.
410            *
411            * <p>
412            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
413            * </p>
414            *
415            * @param uuid the uuid
416            * @param companyId the company ID
417            * @param start the lower bound of the range of blogs entries
418            * @param end the upper bound of the range of blogs entries (not inclusive)
419            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
420            * @return the ordered range of matching blogs entries
421            * @throws SystemException if a system exception occurred
422            */
423            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByUuid_C(
424                    java.lang.String uuid, long companyId, int start, int end,
425                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
426                    throws com.liferay.portal.kernel.exception.SystemException {
427                    return getPersistence()
428                                       .findByUuid_C(uuid, companyId, start, end, orderByComparator);
429            }
430    
431            /**
432            * Returns the first blogs entry in the ordered set where uuid = &#63; and companyId = &#63;.
433            *
434            * @param uuid the uuid
435            * @param companyId the company ID
436            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
437            * @return the first matching blogs entry
438            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
439            * @throws SystemException if a system exception occurred
440            */
441            public static com.liferay.portlet.blogs.model.BlogsEntry findByUuid_C_First(
442                    java.lang.String uuid, long companyId,
443                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
444                    throws com.liferay.portal.kernel.exception.SystemException,
445                            com.liferay.portlet.blogs.NoSuchEntryException {
446                    return getPersistence()
447                                       .findByUuid_C_First(uuid, companyId, orderByComparator);
448            }
449    
450            /**
451            * Returns the first blogs entry in the ordered set where uuid = &#63; and companyId = &#63;.
452            *
453            * @param uuid the uuid
454            * @param companyId the company ID
455            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
456            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
457            * @throws SystemException if a system exception occurred
458            */
459            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByUuid_C_First(
460                    java.lang.String uuid, long companyId,
461                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
462                    throws com.liferay.portal.kernel.exception.SystemException {
463                    return getPersistence()
464                                       .fetchByUuid_C_First(uuid, companyId, orderByComparator);
465            }
466    
467            /**
468            * Returns the last blogs entry in the ordered set where uuid = &#63; and companyId = &#63;.
469            *
470            * @param uuid the uuid
471            * @param companyId the company ID
472            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
473            * @return the last matching blogs entry
474            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
475            * @throws SystemException if a system exception occurred
476            */
477            public static com.liferay.portlet.blogs.model.BlogsEntry findByUuid_C_Last(
478                    java.lang.String uuid, long companyId,
479                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
480                    throws com.liferay.portal.kernel.exception.SystemException,
481                            com.liferay.portlet.blogs.NoSuchEntryException {
482                    return getPersistence()
483                                       .findByUuid_C_Last(uuid, companyId, orderByComparator);
484            }
485    
486            /**
487            * Returns the last blogs entry in the ordered set where uuid = &#63; and companyId = &#63;.
488            *
489            * @param uuid the uuid
490            * @param companyId the company ID
491            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
492            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
493            * @throws SystemException if a system exception occurred
494            */
495            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByUuid_C_Last(
496                    java.lang.String uuid, long companyId,
497                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
498                    throws com.liferay.portal.kernel.exception.SystemException {
499                    return getPersistence()
500                                       .fetchByUuid_C_Last(uuid, companyId, orderByComparator);
501            }
502    
503            /**
504            * Returns the blogs entries before and after the current blogs entry in the ordered set where uuid = &#63; and companyId = &#63;.
505            *
506            * @param entryId the primary key of the current blogs entry
507            * @param uuid the uuid
508            * @param companyId the company ID
509            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
510            * @return the previous, current, and next blogs entry
511            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
512            * @throws SystemException if a system exception occurred
513            */
514            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByUuid_C_PrevAndNext(
515                    long entryId, java.lang.String uuid, long companyId,
516                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
517                    throws com.liferay.portal.kernel.exception.SystemException,
518                            com.liferay.portlet.blogs.NoSuchEntryException {
519                    return getPersistence()
520                                       .findByUuid_C_PrevAndNext(entryId, uuid, companyId,
521                            orderByComparator);
522            }
523    
524            /**
525            * Returns all the blogs entries where groupId = &#63;.
526            *
527            * @param groupId the group ID
528            * @return the matching blogs entries
529            * @throws SystemException if a system exception occurred
530            */
531            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByGroupId(
532                    long groupId)
533                    throws com.liferay.portal.kernel.exception.SystemException {
534                    return getPersistence().findByGroupId(groupId);
535            }
536    
537            /**
538            * Returns a range of all the blogs entries where groupId = &#63;.
539            *
540            * <p>
541            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
542            * </p>
543            *
544            * @param groupId the group ID
545            * @param start the lower bound of the range of blogs entries
546            * @param end the upper bound of the range of blogs entries (not inclusive)
547            * @return the range of matching blogs entries
548            * @throws SystemException if a system exception occurred
549            */
550            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByGroupId(
551                    long groupId, int start, int end)
552                    throws com.liferay.portal.kernel.exception.SystemException {
553                    return getPersistence().findByGroupId(groupId, start, end);
554            }
555    
556            /**
557            * Returns an ordered range of all the blogs entries where groupId = &#63;.
558            *
559            * <p>
560            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
561            * </p>
562            *
563            * @param groupId the group ID
564            * @param start the lower bound of the range of blogs entries
565            * @param end the upper bound of the range of blogs entries (not inclusive)
566            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
567            * @return the ordered range of matching blogs entries
568            * @throws SystemException if a system exception occurred
569            */
570            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByGroupId(
571                    long groupId, int start, int end,
572                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
573                    throws com.liferay.portal.kernel.exception.SystemException {
574                    return getPersistence()
575                                       .findByGroupId(groupId, start, end, orderByComparator);
576            }
577    
578            /**
579            * Returns the first blogs entry in the ordered set where groupId = &#63;.
580            *
581            * @param groupId the group ID
582            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
583            * @return the first matching blogs entry
584            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
585            * @throws SystemException if a system exception occurred
586            */
587            public static com.liferay.portlet.blogs.model.BlogsEntry findByGroupId_First(
588                    long groupId,
589                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
590                    throws com.liferay.portal.kernel.exception.SystemException,
591                            com.liferay.portlet.blogs.NoSuchEntryException {
592                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
593            }
594    
595            /**
596            * Returns the first blogs entry in the ordered set where groupId = &#63;.
597            *
598            * @param groupId the group ID
599            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
600            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
601            * @throws SystemException if a system exception occurred
602            */
603            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByGroupId_First(
604                    long groupId,
605                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
606                    throws com.liferay.portal.kernel.exception.SystemException {
607                    return getPersistence().fetchByGroupId_First(groupId, orderByComparator);
608            }
609    
610            /**
611            * Returns the last blogs entry in the ordered set where groupId = &#63;.
612            *
613            * @param groupId the group ID
614            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
615            * @return the last matching blogs entry
616            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
617            * @throws SystemException if a system exception occurred
618            */
619            public static com.liferay.portlet.blogs.model.BlogsEntry findByGroupId_Last(
620                    long groupId,
621                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
622                    throws com.liferay.portal.kernel.exception.SystemException,
623                            com.liferay.portlet.blogs.NoSuchEntryException {
624                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
625            }
626    
627            /**
628            * Returns the last blogs entry in the ordered set where groupId = &#63;.
629            *
630            * @param groupId the group ID
631            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
632            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
633            * @throws SystemException if a system exception occurred
634            */
635            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByGroupId_Last(
636                    long groupId,
637                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
638                    throws com.liferay.portal.kernel.exception.SystemException {
639                    return getPersistence().fetchByGroupId_Last(groupId, orderByComparator);
640            }
641    
642            /**
643            * Returns the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63;.
644            *
645            * @param entryId the primary key of the current blogs entry
646            * @param groupId the group ID
647            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
648            * @return the previous, current, and next blogs entry
649            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
650            * @throws SystemException if a system exception occurred
651            */
652            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByGroupId_PrevAndNext(
653                    long entryId, long groupId,
654                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
655                    throws com.liferay.portal.kernel.exception.SystemException,
656                            com.liferay.portlet.blogs.NoSuchEntryException {
657                    return getPersistence()
658                                       .findByGroupId_PrevAndNext(entryId, groupId,
659                            orderByComparator);
660            }
661    
662            /**
663            * Returns all the blogs entries that the user has permission to view where groupId = &#63;.
664            *
665            * @param groupId the group ID
666            * @return the matching blogs entries that the user has permission to view
667            * @throws SystemException if a system exception occurred
668            */
669            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByGroupId(
670                    long groupId)
671                    throws com.liferay.portal.kernel.exception.SystemException {
672                    return getPersistence().filterFindByGroupId(groupId);
673            }
674    
675            /**
676            * Returns a range of all the blogs entries that the user has permission to view where groupId = &#63;.
677            *
678            * <p>
679            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
680            * </p>
681            *
682            * @param groupId the group ID
683            * @param start the lower bound of the range of blogs entries
684            * @param end the upper bound of the range of blogs entries (not inclusive)
685            * @return the range of matching blogs entries that the user has permission to view
686            * @throws SystemException if a system exception occurred
687            */
688            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByGroupId(
689                    long groupId, int start, int end)
690                    throws com.liferay.portal.kernel.exception.SystemException {
691                    return getPersistence().filterFindByGroupId(groupId, start, end);
692            }
693    
694            /**
695            * Returns an ordered range of all the blogs entries that the user has permissions to view where groupId = &#63;.
696            *
697            * <p>
698            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
699            * </p>
700            *
701            * @param groupId the group ID
702            * @param start the lower bound of the range of blogs entries
703            * @param end the upper bound of the range of blogs entries (not inclusive)
704            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
705            * @return the ordered range of matching blogs entries that the user has permission to view
706            * @throws SystemException if a system exception occurred
707            */
708            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByGroupId(
709                    long groupId, int start, int end,
710                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
711                    throws com.liferay.portal.kernel.exception.SystemException {
712                    return getPersistence()
713                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
714            }
715    
716            /**
717            * Returns the blogs entries before and after the current blogs entry in the ordered set of blogs entries that the user has permission to view where groupId = &#63;.
718            *
719            * @param entryId the primary key of the current blogs entry
720            * @param groupId the group ID
721            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
722            * @return the previous, current, and next blogs entry
723            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
724            * @throws SystemException if a system exception occurred
725            */
726            public static com.liferay.portlet.blogs.model.BlogsEntry[] filterFindByGroupId_PrevAndNext(
727                    long entryId, long groupId,
728                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
729                    throws com.liferay.portal.kernel.exception.SystemException,
730                            com.liferay.portlet.blogs.NoSuchEntryException {
731                    return getPersistence()
732                                       .filterFindByGroupId_PrevAndNext(entryId, groupId,
733                            orderByComparator);
734            }
735    
736            /**
737            * Returns all the blogs entries where companyId = &#63;.
738            *
739            * @param companyId the company ID
740            * @return the matching blogs entries
741            * @throws SystemException if a system exception occurred
742            */
743            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByCompanyId(
744                    long companyId)
745                    throws com.liferay.portal.kernel.exception.SystemException {
746                    return getPersistence().findByCompanyId(companyId);
747            }
748    
749            /**
750            * Returns a range of all the blogs entries where companyId = &#63;.
751            *
752            * <p>
753            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
754            * </p>
755            *
756            * @param companyId the company ID
757            * @param start the lower bound of the range of blogs entries
758            * @param end the upper bound of the range of blogs entries (not inclusive)
759            * @return the range of matching blogs entries
760            * @throws SystemException if a system exception occurred
761            */
762            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByCompanyId(
763                    long companyId, int start, int end)
764                    throws com.liferay.portal.kernel.exception.SystemException {
765                    return getPersistence().findByCompanyId(companyId, start, end);
766            }
767    
768            /**
769            * Returns an ordered range of all the blogs entries where companyId = &#63;.
770            *
771            * <p>
772            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
773            * </p>
774            *
775            * @param companyId the company ID
776            * @param start the lower bound of the range of blogs entries
777            * @param end the upper bound of the range of blogs entries (not inclusive)
778            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
779            * @return the ordered range of matching blogs entries
780            * @throws SystemException if a system exception occurred
781            */
782            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByCompanyId(
783                    long companyId, int start, int end,
784                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
785                    throws com.liferay.portal.kernel.exception.SystemException {
786                    return getPersistence()
787                                       .findByCompanyId(companyId, start, end, orderByComparator);
788            }
789    
790            /**
791            * Returns the first blogs entry in the ordered set where companyId = &#63;.
792            *
793            * @param companyId the company ID
794            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
795            * @return the first matching blogs entry
796            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
797            * @throws SystemException if a system exception occurred
798            */
799            public static com.liferay.portlet.blogs.model.BlogsEntry findByCompanyId_First(
800                    long companyId,
801                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
802                    throws com.liferay.portal.kernel.exception.SystemException,
803                            com.liferay.portlet.blogs.NoSuchEntryException {
804                    return getPersistence()
805                                       .findByCompanyId_First(companyId, orderByComparator);
806            }
807    
808            /**
809            * Returns the first blogs entry in the ordered set where companyId = &#63;.
810            *
811            * @param companyId the company ID
812            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
813            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
814            * @throws SystemException if a system exception occurred
815            */
816            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByCompanyId_First(
817                    long companyId,
818                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
819                    throws com.liferay.portal.kernel.exception.SystemException {
820                    return getPersistence()
821                                       .fetchByCompanyId_First(companyId, orderByComparator);
822            }
823    
824            /**
825            * Returns the last blogs entry in the ordered set where companyId = &#63;.
826            *
827            * @param companyId the company ID
828            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
829            * @return the last matching blogs entry
830            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
831            * @throws SystemException if a system exception occurred
832            */
833            public static com.liferay.portlet.blogs.model.BlogsEntry findByCompanyId_Last(
834                    long companyId,
835                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
836                    throws com.liferay.portal.kernel.exception.SystemException,
837                            com.liferay.portlet.blogs.NoSuchEntryException {
838                    return getPersistence()
839                                       .findByCompanyId_Last(companyId, orderByComparator);
840            }
841    
842            /**
843            * Returns the last blogs entry in the ordered set where companyId = &#63;.
844            *
845            * @param companyId the company ID
846            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
847            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
848            * @throws SystemException if a system exception occurred
849            */
850            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByCompanyId_Last(
851                    long companyId,
852                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
853                    throws com.liferay.portal.kernel.exception.SystemException {
854                    return getPersistence()
855                                       .fetchByCompanyId_Last(companyId, orderByComparator);
856            }
857    
858            /**
859            * Returns the blogs entries before and after the current blogs entry in the ordered set where companyId = &#63;.
860            *
861            * @param entryId the primary key of the current blogs entry
862            * @param companyId the company ID
863            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
864            * @return the previous, current, and next blogs entry
865            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
866            * @throws SystemException if a system exception occurred
867            */
868            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByCompanyId_PrevAndNext(
869                    long entryId, long companyId,
870                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
871                    throws com.liferay.portal.kernel.exception.SystemException,
872                            com.liferay.portlet.blogs.NoSuchEntryException {
873                    return getPersistence()
874                                       .findByCompanyId_PrevAndNext(entryId, companyId,
875                            orderByComparator);
876            }
877    
878            /**
879            * Returns all the blogs entries where companyId = &#63; and userId = &#63;.
880            *
881            * @param companyId the company ID
882            * @param userId the user ID
883            * @return the matching blogs entries
884            * @throws SystemException if a system exception occurred
885            */
886            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_U(
887                    long companyId, long userId)
888                    throws com.liferay.portal.kernel.exception.SystemException {
889                    return getPersistence().findByC_U(companyId, userId);
890            }
891    
892            /**
893            * Returns a range of all the blogs entries where companyId = &#63; and userId = &#63;.
894            *
895            * <p>
896            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
897            * </p>
898            *
899            * @param companyId the company ID
900            * @param userId the user ID
901            * @param start the lower bound of the range of blogs entries
902            * @param end the upper bound of the range of blogs entries (not inclusive)
903            * @return the range of matching blogs entries
904            * @throws SystemException if a system exception occurred
905            */
906            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_U(
907                    long companyId, long userId, int start, int end)
908                    throws com.liferay.portal.kernel.exception.SystemException {
909                    return getPersistence().findByC_U(companyId, userId, start, end);
910            }
911    
912            /**
913            * Returns an ordered range of all the blogs entries where companyId = &#63; and userId = &#63;.
914            *
915            * <p>
916            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
917            * </p>
918            *
919            * @param companyId the company ID
920            * @param userId the user ID
921            * @param start the lower bound of the range of blogs entries
922            * @param end the upper bound of the range of blogs entries (not inclusive)
923            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
924            * @return the ordered range of matching blogs entries
925            * @throws SystemException if a system exception occurred
926            */
927            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_U(
928                    long companyId, long userId, int start, int end,
929                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
930                    throws com.liferay.portal.kernel.exception.SystemException {
931                    return getPersistence()
932                                       .findByC_U(companyId, userId, start, end, orderByComparator);
933            }
934    
935            /**
936            * Returns the first blogs entry in the ordered set where companyId = &#63; and userId = &#63;.
937            *
938            * @param companyId the company ID
939            * @param userId the user ID
940            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
941            * @return the first matching blogs entry
942            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
943            * @throws SystemException if a system exception occurred
944            */
945            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_U_First(
946                    long companyId, long userId,
947                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
948                    throws com.liferay.portal.kernel.exception.SystemException,
949                            com.liferay.portlet.blogs.NoSuchEntryException {
950                    return getPersistence()
951                                       .findByC_U_First(companyId, userId, orderByComparator);
952            }
953    
954            /**
955            * Returns the first blogs entry in the ordered set where companyId = &#63; and userId = &#63;.
956            *
957            * @param companyId the company ID
958            * @param userId the user ID
959            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
960            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
961            * @throws SystemException if a system exception occurred
962            */
963            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByC_U_First(
964                    long companyId, long userId,
965                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
966                    throws com.liferay.portal.kernel.exception.SystemException {
967                    return getPersistence()
968                                       .fetchByC_U_First(companyId, userId, orderByComparator);
969            }
970    
971            /**
972            * Returns the last blogs entry in the ordered set where companyId = &#63; and userId = &#63;.
973            *
974            * @param companyId the company ID
975            * @param userId the user ID
976            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
977            * @return the last matching blogs entry
978            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
979            * @throws SystemException if a system exception occurred
980            */
981            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_U_Last(
982                    long companyId, long userId,
983                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
984                    throws com.liferay.portal.kernel.exception.SystemException,
985                            com.liferay.portlet.blogs.NoSuchEntryException {
986                    return getPersistence()
987                                       .findByC_U_Last(companyId, userId, orderByComparator);
988            }
989    
990            /**
991            * Returns the last blogs entry in the ordered set where companyId = &#63; and userId = &#63;.
992            *
993            * @param companyId the company ID
994            * @param userId the user ID
995            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
996            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
997            * @throws SystemException if a system exception occurred
998            */
999            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByC_U_Last(
1000                    long companyId, long userId,
1001                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1002                    throws com.liferay.portal.kernel.exception.SystemException {
1003                    return getPersistence()
1004                                       .fetchByC_U_Last(companyId, userId, orderByComparator);
1005            }
1006    
1007            /**
1008            * Returns the blogs entries before and after the current blogs entry in the ordered set where companyId = &#63; and userId = &#63;.
1009            *
1010            * @param entryId the primary key of the current blogs entry
1011            * @param companyId the company ID
1012            * @param userId the user ID
1013            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1014            * @return the previous, current, and next blogs entry
1015            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
1016            * @throws SystemException if a system exception occurred
1017            */
1018            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByC_U_PrevAndNext(
1019                    long entryId, long companyId, long userId,
1020                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1021                    throws com.liferay.portal.kernel.exception.SystemException,
1022                            com.liferay.portlet.blogs.NoSuchEntryException {
1023                    return getPersistence()
1024                                       .findByC_U_PrevAndNext(entryId, companyId, userId,
1025                            orderByComparator);
1026            }
1027    
1028            /**
1029            * Returns all the blogs entries where companyId = &#63; and displayDate &lt; &#63;.
1030            *
1031            * @param companyId the company ID
1032            * @param displayDate the display date
1033            * @return the matching blogs entries
1034            * @throws SystemException if a system exception occurred
1035            */
1036            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_LtD(
1037                    long companyId, java.util.Date displayDate)
1038                    throws com.liferay.portal.kernel.exception.SystemException {
1039                    return getPersistence().findByC_LtD(companyId, displayDate);
1040            }
1041    
1042            /**
1043            * Returns a range of all the blogs entries where companyId = &#63; and displayDate &lt; &#63;.
1044            *
1045            * <p>
1046            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1047            * </p>
1048            *
1049            * @param companyId the company ID
1050            * @param displayDate the display date
1051            * @param start the lower bound of the range of blogs entries
1052            * @param end the upper bound of the range of blogs entries (not inclusive)
1053            * @return the range of matching blogs entries
1054            * @throws SystemException if a system exception occurred
1055            */
1056            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_LtD(
1057                    long companyId, java.util.Date displayDate, int start, int end)
1058                    throws com.liferay.portal.kernel.exception.SystemException {
1059                    return getPersistence().findByC_LtD(companyId, displayDate, start, end);
1060            }
1061    
1062            /**
1063            * Returns an ordered range of all the blogs entries where companyId = &#63; and displayDate &lt; &#63;.
1064            *
1065            * <p>
1066            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1067            * </p>
1068            *
1069            * @param companyId the company ID
1070            * @param displayDate the display date
1071            * @param start the lower bound of the range of blogs entries
1072            * @param end the upper bound of the range of blogs entries (not inclusive)
1073            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1074            * @return the ordered range of matching blogs entries
1075            * @throws SystemException if a system exception occurred
1076            */
1077            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_LtD(
1078                    long companyId, java.util.Date displayDate, int start, int end,
1079                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1080                    throws com.liferay.portal.kernel.exception.SystemException {
1081                    return getPersistence()
1082                                       .findByC_LtD(companyId, displayDate, start, end,
1083                            orderByComparator);
1084            }
1085    
1086            /**
1087            * Returns the first blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63;.
1088            *
1089            * @param companyId the company ID
1090            * @param displayDate the display date
1091            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1092            * @return the first matching blogs entry
1093            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1094            * @throws SystemException if a system exception occurred
1095            */
1096            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_LtD_First(
1097                    long companyId, java.util.Date displayDate,
1098                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1099                    throws com.liferay.portal.kernel.exception.SystemException,
1100                            com.liferay.portlet.blogs.NoSuchEntryException {
1101                    return getPersistence()
1102                                       .findByC_LtD_First(companyId, displayDate, orderByComparator);
1103            }
1104    
1105            /**
1106            * Returns the first blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63;.
1107            *
1108            * @param companyId the company ID
1109            * @param displayDate the display date
1110            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1111            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
1112            * @throws SystemException if a system exception occurred
1113            */
1114            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByC_LtD_First(
1115                    long companyId, java.util.Date displayDate,
1116                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1117                    throws com.liferay.portal.kernel.exception.SystemException {
1118                    return getPersistence()
1119                                       .fetchByC_LtD_First(companyId, displayDate, orderByComparator);
1120            }
1121    
1122            /**
1123            * Returns the last blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63;.
1124            *
1125            * @param companyId the company ID
1126            * @param displayDate the display date
1127            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1128            * @return the last matching blogs entry
1129            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1130            * @throws SystemException if a system exception occurred
1131            */
1132            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_LtD_Last(
1133                    long companyId, java.util.Date displayDate,
1134                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1135                    throws com.liferay.portal.kernel.exception.SystemException,
1136                            com.liferay.portlet.blogs.NoSuchEntryException {
1137                    return getPersistence()
1138                                       .findByC_LtD_Last(companyId, displayDate, orderByComparator);
1139            }
1140    
1141            /**
1142            * Returns the last blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63;.
1143            *
1144            * @param companyId the company ID
1145            * @param displayDate the display date
1146            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1147            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
1148            * @throws SystemException if a system exception occurred
1149            */
1150            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByC_LtD_Last(
1151                    long companyId, java.util.Date displayDate,
1152                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1153                    throws com.liferay.portal.kernel.exception.SystemException {
1154                    return getPersistence()
1155                                       .fetchByC_LtD_Last(companyId, displayDate, orderByComparator);
1156            }
1157    
1158            /**
1159            * Returns the blogs entries before and after the current blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63;.
1160            *
1161            * @param entryId the primary key of the current blogs entry
1162            * @param companyId the company ID
1163            * @param displayDate the display date
1164            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1165            * @return the previous, current, and next blogs entry
1166            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
1167            * @throws SystemException if a system exception occurred
1168            */
1169            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByC_LtD_PrevAndNext(
1170                    long entryId, long companyId, java.util.Date displayDate,
1171                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1172                    throws com.liferay.portal.kernel.exception.SystemException,
1173                            com.liferay.portlet.blogs.NoSuchEntryException {
1174                    return getPersistence()
1175                                       .findByC_LtD_PrevAndNext(entryId, companyId, displayDate,
1176                            orderByComparator);
1177            }
1178    
1179            /**
1180            * Returns all the blogs entries where companyId = &#63; and status &ne; &#63;.
1181            *
1182            * @param companyId the company ID
1183            * @param status the status
1184            * @return the matching blogs entries
1185            * @throws SystemException if a system exception occurred
1186            */
1187            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_NeS(
1188                    long companyId, int status)
1189                    throws com.liferay.portal.kernel.exception.SystemException {
1190                    return getPersistence().findByC_NeS(companyId, status);
1191            }
1192    
1193            /**
1194            * Returns a range of all the blogs entries where companyId = &#63; and status &ne; &#63;.
1195            *
1196            * <p>
1197            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1198            * </p>
1199            *
1200            * @param companyId the company ID
1201            * @param status the status
1202            * @param start the lower bound of the range of blogs entries
1203            * @param end the upper bound of the range of blogs entries (not inclusive)
1204            * @return the range of matching blogs entries
1205            * @throws SystemException if a system exception occurred
1206            */
1207            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_NeS(
1208                    long companyId, int status, int start, int end)
1209                    throws com.liferay.portal.kernel.exception.SystemException {
1210                    return getPersistence().findByC_NeS(companyId, status, start, end);
1211            }
1212    
1213            /**
1214            * Returns an ordered range of all the blogs entries where companyId = &#63; and status &ne; &#63;.
1215            *
1216            * <p>
1217            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1218            * </p>
1219            *
1220            * @param companyId the company ID
1221            * @param status the status
1222            * @param start the lower bound of the range of blogs entries
1223            * @param end the upper bound of the range of blogs entries (not inclusive)
1224            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1225            * @return the ordered range of matching blogs entries
1226            * @throws SystemException if a system exception occurred
1227            */
1228            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_NeS(
1229                    long companyId, int status, int start, int end,
1230                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1231                    throws com.liferay.portal.kernel.exception.SystemException {
1232                    return getPersistence()
1233                                       .findByC_NeS(companyId, status, start, end, orderByComparator);
1234            }
1235    
1236            /**
1237            * Returns the first blogs entry in the ordered set where companyId = &#63; and status &ne; &#63;.
1238            *
1239            * @param companyId the company ID
1240            * @param status the status
1241            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1242            * @return the first matching blogs entry
1243            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1244            * @throws SystemException if a system exception occurred
1245            */
1246            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_NeS_First(
1247                    long companyId, int status,
1248                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1249                    throws com.liferay.portal.kernel.exception.SystemException,
1250                            com.liferay.portlet.blogs.NoSuchEntryException {
1251                    return getPersistence()
1252                                       .findByC_NeS_First(companyId, status, orderByComparator);
1253            }
1254    
1255            /**
1256            * Returns the first blogs entry in the ordered set where companyId = &#63; and status &ne; &#63;.
1257            *
1258            * @param companyId the company ID
1259            * @param status the status
1260            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1261            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
1262            * @throws SystemException if a system exception occurred
1263            */
1264            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByC_NeS_First(
1265                    long companyId, int status,
1266                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1267                    throws com.liferay.portal.kernel.exception.SystemException {
1268                    return getPersistence()
1269                                       .fetchByC_NeS_First(companyId, status, orderByComparator);
1270            }
1271    
1272            /**
1273            * Returns the last blogs entry in the ordered set where companyId = &#63; and status &ne; &#63;.
1274            *
1275            * @param companyId the company ID
1276            * @param status the status
1277            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1278            * @return the last matching blogs entry
1279            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1280            * @throws SystemException if a system exception occurred
1281            */
1282            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_NeS_Last(
1283                    long companyId, int status,
1284                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1285                    throws com.liferay.portal.kernel.exception.SystemException,
1286                            com.liferay.portlet.blogs.NoSuchEntryException {
1287                    return getPersistence()
1288                                       .findByC_NeS_Last(companyId, status, orderByComparator);
1289            }
1290    
1291            /**
1292            * Returns the last blogs entry in the ordered set where companyId = &#63; and status &ne; &#63;.
1293            *
1294            * @param companyId the company ID
1295            * @param status the status
1296            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1297            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
1298            * @throws SystemException if a system exception occurred
1299            */
1300            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByC_NeS_Last(
1301                    long companyId, int status,
1302                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1303                    throws com.liferay.portal.kernel.exception.SystemException {
1304                    return getPersistence()
1305                                       .fetchByC_NeS_Last(companyId, status, orderByComparator);
1306            }
1307    
1308            /**
1309            * Returns the blogs entries before and after the current blogs entry in the ordered set where companyId = &#63; and status &ne; &#63;.
1310            *
1311            * @param entryId the primary key of the current blogs entry
1312            * @param companyId the company ID
1313            * @param status the status
1314            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1315            * @return the previous, current, and next blogs entry
1316            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
1317            * @throws SystemException if a system exception occurred
1318            */
1319            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByC_NeS_PrevAndNext(
1320                    long entryId, long companyId, int status,
1321                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1322                    throws com.liferay.portal.kernel.exception.SystemException,
1323                            com.liferay.portlet.blogs.NoSuchEntryException {
1324                    return getPersistence()
1325                                       .findByC_NeS_PrevAndNext(entryId, companyId, status,
1326                            orderByComparator);
1327            }
1328    
1329            /**
1330            * Returns all the blogs entries where companyId = &#63; and status = &#63;.
1331            *
1332            * @param companyId the company ID
1333            * @param status the status
1334            * @return the matching blogs entries
1335            * @throws SystemException if a system exception occurred
1336            */
1337            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_S(
1338                    long companyId, int status)
1339                    throws com.liferay.portal.kernel.exception.SystemException {
1340                    return getPersistence().findByC_S(companyId, status);
1341            }
1342    
1343            /**
1344            * Returns a range of all the blogs entries where companyId = &#63; and status = &#63;.
1345            *
1346            * <p>
1347            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1348            * </p>
1349            *
1350            * @param companyId the company ID
1351            * @param status the status
1352            * @param start the lower bound of the range of blogs entries
1353            * @param end the upper bound of the range of blogs entries (not inclusive)
1354            * @return the range of matching blogs entries
1355            * @throws SystemException if a system exception occurred
1356            */
1357            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_S(
1358                    long companyId, int status, int start, int end)
1359                    throws com.liferay.portal.kernel.exception.SystemException {
1360                    return getPersistence().findByC_S(companyId, status, start, end);
1361            }
1362    
1363            /**
1364            * Returns an ordered range of all the blogs entries where companyId = &#63; and status = &#63;.
1365            *
1366            * <p>
1367            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1368            * </p>
1369            *
1370            * @param companyId the company ID
1371            * @param status the status
1372            * @param start the lower bound of the range of blogs entries
1373            * @param end the upper bound of the range of blogs entries (not inclusive)
1374            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1375            * @return the ordered range of matching blogs entries
1376            * @throws SystemException if a system exception occurred
1377            */
1378            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_S(
1379                    long companyId, int status, int start, int end,
1380                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1381                    throws com.liferay.portal.kernel.exception.SystemException {
1382                    return getPersistence()
1383                                       .findByC_S(companyId, status, start, end, orderByComparator);
1384            }
1385    
1386            /**
1387            * Returns the first blogs entry in the ordered set where companyId = &#63; and status = &#63;.
1388            *
1389            * @param companyId the company ID
1390            * @param status the status
1391            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1392            * @return the first matching blogs entry
1393            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1394            * @throws SystemException if a system exception occurred
1395            */
1396            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_S_First(
1397                    long companyId, int status,
1398                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1399                    throws com.liferay.portal.kernel.exception.SystemException,
1400                            com.liferay.portlet.blogs.NoSuchEntryException {
1401                    return getPersistence()
1402                                       .findByC_S_First(companyId, status, orderByComparator);
1403            }
1404    
1405            /**
1406            * Returns the first blogs entry in the ordered set where companyId = &#63; and status = &#63;.
1407            *
1408            * @param companyId the company ID
1409            * @param status the status
1410            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1411            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
1412            * @throws SystemException if a system exception occurred
1413            */
1414            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByC_S_First(
1415                    long companyId, int status,
1416                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1417                    throws com.liferay.portal.kernel.exception.SystemException {
1418                    return getPersistence()
1419                                       .fetchByC_S_First(companyId, status, orderByComparator);
1420            }
1421    
1422            /**
1423            * Returns the last blogs entry in the ordered set where companyId = &#63; and status = &#63;.
1424            *
1425            * @param companyId the company ID
1426            * @param status the status
1427            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1428            * @return the last matching blogs entry
1429            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1430            * @throws SystemException if a system exception occurred
1431            */
1432            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_S_Last(
1433                    long companyId, int status,
1434                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1435                    throws com.liferay.portal.kernel.exception.SystemException,
1436                            com.liferay.portlet.blogs.NoSuchEntryException {
1437                    return getPersistence()
1438                                       .findByC_S_Last(companyId, status, orderByComparator);
1439            }
1440    
1441            /**
1442            * Returns the last blogs entry in the ordered set where companyId = &#63; and status = &#63;.
1443            *
1444            * @param companyId the company ID
1445            * @param status the status
1446            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1447            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
1448            * @throws SystemException if a system exception occurred
1449            */
1450            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByC_S_Last(
1451                    long companyId, int status,
1452                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1453                    throws com.liferay.portal.kernel.exception.SystemException {
1454                    return getPersistence()
1455                                       .fetchByC_S_Last(companyId, status, orderByComparator);
1456            }
1457    
1458            /**
1459            * Returns the blogs entries before and after the current blogs entry in the ordered set where companyId = &#63; and status = &#63;.
1460            *
1461            * @param entryId the primary key of the current blogs entry
1462            * @param companyId the company ID
1463            * @param status the status
1464            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1465            * @return the previous, current, and next blogs entry
1466            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
1467            * @throws SystemException if a system exception occurred
1468            */
1469            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByC_S_PrevAndNext(
1470                    long entryId, long companyId, int status,
1471                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1472                    throws com.liferay.portal.kernel.exception.SystemException,
1473                            com.liferay.portlet.blogs.NoSuchEntryException {
1474                    return getPersistence()
1475                                       .findByC_S_PrevAndNext(entryId, companyId, status,
1476                            orderByComparator);
1477            }
1478    
1479            /**
1480            * Returns the blogs entry where groupId = &#63; and urlTitle = &#63; or throws a {@link com.liferay.portlet.blogs.NoSuchEntryException} if it could not be found.
1481            *
1482            * @param groupId the group ID
1483            * @param urlTitle the url title
1484            * @return the matching blogs entry
1485            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1486            * @throws SystemException if a system exception occurred
1487            */
1488            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_UT(
1489                    long groupId, java.lang.String urlTitle)
1490                    throws com.liferay.portal.kernel.exception.SystemException,
1491                            com.liferay.portlet.blogs.NoSuchEntryException {
1492                    return getPersistence().findByG_UT(groupId, urlTitle);
1493            }
1494    
1495            /**
1496            * Returns the blogs entry where groupId = &#63; and urlTitle = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1497            *
1498            * @param groupId the group ID
1499            * @param urlTitle the url title
1500            * @return the matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
1501            * @throws SystemException if a system exception occurred
1502            */
1503            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_UT(
1504                    long groupId, java.lang.String urlTitle)
1505                    throws com.liferay.portal.kernel.exception.SystemException {
1506                    return getPersistence().fetchByG_UT(groupId, urlTitle);
1507            }
1508    
1509            /**
1510            * Returns the blogs entry where groupId = &#63; and urlTitle = &#63; or returns <code>null</code> if it could not be found, optionally using the finder cache.
1511            *
1512            * @param groupId the group ID
1513            * @param urlTitle the url title
1514            * @param retrieveFromCache whether to use the finder cache
1515            * @return the matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
1516            * @throws SystemException if a system exception occurred
1517            */
1518            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_UT(
1519                    long groupId, java.lang.String urlTitle, boolean retrieveFromCache)
1520                    throws com.liferay.portal.kernel.exception.SystemException {
1521                    return getPersistence().fetchByG_UT(groupId, urlTitle, retrieveFromCache);
1522            }
1523    
1524            /**
1525            * Returns all the blogs entries where groupId = &#63; and displayDate &lt; &#63;.
1526            *
1527            * @param groupId the group ID
1528            * @param displayDate the display date
1529            * @return the matching blogs entries
1530            * @throws SystemException if a system exception occurred
1531            */
1532            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_LtD(
1533                    long groupId, java.util.Date displayDate)
1534                    throws com.liferay.portal.kernel.exception.SystemException {
1535                    return getPersistence().findByG_LtD(groupId, displayDate);
1536            }
1537    
1538            /**
1539            * Returns a range of all the blogs entries where groupId = &#63; and displayDate &lt; &#63;.
1540            *
1541            * <p>
1542            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1543            * </p>
1544            *
1545            * @param groupId the group ID
1546            * @param displayDate the display date
1547            * @param start the lower bound of the range of blogs entries
1548            * @param end the upper bound of the range of blogs entries (not inclusive)
1549            * @return the range of matching blogs entries
1550            * @throws SystemException if a system exception occurred
1551            */
1552            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_LtD(
1553                    long groupId, java.util.Date displayDate, int start, int end)
1554                    throws com.liferay.portal.kernel.exception.SystemException {
1555                    return getPersistence().findByG_LtD(groupId, displayDate, start, end);
1556            }
1557    
1558            /**
1559            * Returns an ordered range of all the blogs entries where groupId = &#63; and displayDate &lt; &#63;.
1560            *
1561            * <p>
1562            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1563            * </p>
1564            *
1565            * @param groupId the group ID
1566            * @param displayDate the display date
1567            * @param start the lower bound of the range of blogs entries
1568            * @param end the upper bound of the range of blogs entries (not inclusive)
1569            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1570            * @return the ordered range of matching blogs entries
1571            * @throws SystemException if a system exception occurred
1572            */
1573            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_LtD(
1574                    long groupId, java.util.Date displayDate, int start, int end,
1575                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1576                    throws com.liferay.portal.kernel.exception.SystemException {
1577                    return getPersistence()
1578                                       .findByG_LtD(groupId, displayDate, start, end,
1579                            orderByComparator);
1580            }
1581    
1582            /**
1583            * Returns the first blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63;.
1584            *
1585            * @param groupId the group ID
1586            * @param displayDate the display date
1587            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1588            * @return the first matching blogs entry
1589            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1590            * @throws SystemException if a system exception occurred
1591            */
1592            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_LtD_First(
1593                    long groupId, java.util.Date displayDate,
1594                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1595                    throws com.liferay.portal.kernel.exception.SystemException,
1596                            com.liferay.portlet.blogs.NoSuchEntryException {
1597                    return getPersistence()
1598                                       .findByG_LtD_First(groupId, displayDate, orderByComparator);
1599            }
1600    
1601            /**
1602            * Returns the first blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63;.
1603            *
1604            * @param groupId the group ID
1605            * @param displayDate the display date
1606            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1607            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
1608            * @throws SystemException if a system exception occurred
1609            */
1610            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_LtD_First(
1611                    long groupId, java.util.Date displayDate,
1612                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1613                    throws com.liferay.portal.kernel.exception.SystemException {
1614                    return getPersistence()
1615                                       .fetchByG_LtD_First(groupId, displayDate, orderByComparator);
1616            }
1617    
1618            /**
1619            * Returns the last blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63;.
1620            *
1621            * @param groupId the group ID
1622            * @param displayDate the display date
1623            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1624            * @return the last matching blogs entry
1625            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1626            * @throws SystemException if a system exception occurred
1627            */
1628            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_LtD_Last(
1629                    long groupId, java.util.Date displayDate,
1630                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1631                    throws com.liferay.portal.kernel.exception.SystemException,
1632                            com.liferay.portlet.blogs.NoSuchEntryException {
1633                    return getPersistence()
1634                                       .findByG_LtD_Last(groupId, displayDate, orderByComparator);
1635            }
1636    
1637            /**
1638            * Returns the last blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63;.
1639            *
1640            * @param groupId the group ID
1641            * @param displayDate the display date
1642            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1643            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
1644            * @throws SystemException if a system exception occurred
1645            */
1646            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_LtD_Last(
1647                    long groupId, java.util.Date displayDate,
1648                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1649                    throws com.liferay.portal.kernel.exception.SystemException {
1650                    return getPersistence()
1651                                       .fetchByG_LtD_Last(groupId, displayDate, orderByComparator);
1652            }
1653    
1654            /**
1655            * Returns the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63;.
1656            *
1657            * @param entryId the primary key of the current blogs entry
1658            * @param groupId the group ID
1659            * @param displayDate the display date
1660            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1661            * @return the previous, current, and next blogs entry
1662            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
1663            * @throws SystemException if a system exception occurred
1664            */
1665            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByG_LtD_PrevAndNext(
1666                    long entryId, long groupId, java.util.Date displayDate,
1667                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1668                    throws com.liferay.portal.kernel.exception.SystemException,
1669                            com.liferay.portlet.blogs.NoSuchEntryException {
1670                    return getPersistence()
1671                                       .findByG_LtD_PrevAndNext(entryId, groupId, displayDate,
1672                            orderByComparator);
1673            }
1674    
1675            /**
1676            * Returns all the blogs entries that the user has permission to view where groupId = &#63; and displayDate &lt; &#63;.
1677            *
1678            * @param groupId the group ID
1679            * @param displayDate the display date
1680            * @return the matching blogs entries that the user has permission to view
1681            * @throws SystemException if a system exception occurred
1682            */
1683            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_LtD(
1684                    long groupId, java.util.Date displayDate)
1685                    throws com.liferay.portal.kernel.exception.SystemException {
1686                    return getPersistence().filterFindByG_LtD(groupId, displayDate);
1687            }
1688    
1689            /**
1690            * Returns a range of all the blogs entries that the user has permission to view where groupId = &#63; and displayDate &lt; &#63;.
1691            *
1692            * <p>
1693            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1694            * </p>
1695            *
1696            * @param groupId the group ID
1697            * @param displayDate the display date
1698            * @param start the lower bound of the range of blogs entries
1699            * @param end the upper bound of the range of blogs entries (not inclusive)
1700            * @return the range of matching blogs entries that the user has permission to view
1701            * @throws SystemException if a system exception occurred
1702            */
1703            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_LtD(
1704                    long groupId, java.util.Date displayDate, int start, int end)
1705                    throws com.liferay.portal.kernel.exception.SystemException {
1706                    return getPersistence()
1707                                       .filterFindByG_LtD(groupId, displayDate, start, end);
1708            }
1709    
1710            /**
1711            * Returns an ordered range of all the blogs entries that the user has permissions to view where groupId = &#63; and displayDate &lt; &#63;.
1712            *
1713            * <p>
1714            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1715            * </p>
1716            *
1717            * @param groupId the group ID
1718            * @param displayDate the display date
1719            * @param start the lower bound of the range of blogs entries
1720            * @param end the upper bound of the range of blogs entries (not inclusive)
1721            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1722            * @return the ordered range of matching blogs entries that the user has permission to view
1723            * @throws SystemException if a system exception occurred
1724            */
1725            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_LtD(
1726                    long groupId, java.util.Date displayDate, int start, int end,
1727                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1728                    throws com.liferay.portal.kernel.exception.SystemException {
1729                    return getPersistence()
1730                                       .filterFindByG_LtD(groupId, displayDate, start, end,
1731                            orderByComparator);
1732            }
1733    
1734            /**
1735            * Returns the blogs entries before and after the current blogs entry in the ordered set of blogs entries that the user has permission to view where groupId = &#63; and displayDate &lt; &#63;.
1736            *
1737            * @param entryId the primary key of the current blogs entry
1738            * @param groupId the group ID
1739            * @param displayDate the display date
1740            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1741            * @return the previous, current, and next blogs entry
1742            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
1743            * @throws SystemException if a system exception occurred
1744            */
1745            public static com.liferay.portlet.blogs.model.BlogsEntry[] filterFindByG_LtD_PrevAndNext(
1746                    long entryId, long groupId, java.util.Date displayDate,
1747                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1748                    throws com.liferay.portal.kernel.exception.SystemException,
1749                            com.liferay.portlet.blogs.NoSuchEntryException {
1750                    return getPersistence()
1751                                       .filterFindByG_LtD_PrevAndNext(entryId, groupId,
1752                            displayDate, orderByComparator);
1753            }
1754    
1755            /**
1756            * Returns all the blogs entries where groupId = &#63; and status &ne; &#63;.
1757            *
1758            * @param groupId the group ID
1759            * @param status the status
1760            * @return the matching blogs entries
1761            * @throws SystemException if a system exception occurred
1762            */
1763            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_NeS(
1764                    long groupId, int status)
1765                    throws com.liferay.portal.kernel.exception.SystemException {
1766                    return getPersistence().findByG_NeS(groupId, status);
1767            }
1768    
1769            /**
1770            * Returns a range of all the blogs entries where groupId = &#63; and status &ne; &#63;.
1771            *
1772            * <p>
1773            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1774            * </p>
1775            *
1776            * @param groupId the group ID
1777            * @param status the status
1778            * @param start the lower bound of the range of blogs entries
1779            * @param end the upper bound of the range of blogs entries (not inclusive)
1780            * @return the range of matching blogs entries
1781            * @throws SystemException if a system exception occurred
1782            */
1783            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_NeS(
1784                    long groupId, int status, int start, int end)
1785                    throws com.liferay.portal.kernel.exception.SystemException {
1786                    return getPersistence().findByG_NeS(groupId, status, start, end);
1787            }
1788    
1789            /**
1790            * Returns an ordered range of all the blogs entries where groupId = &#63; and status &ne; &#63;.
1791            *
1792            * <p>
1793            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1794            * </p>
1795            *
1796            * @param groupId the group ID
1797            * @param status the status
1798            * @param start the lower bound of the range of blogs entries
1799            * @param end the upper bound of the range of blogs entries (not inclusive)
1800            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1801            * @return the ordered range of matching blogs entries
1802            * @throws SystemException if a system exception occurred
1803            */
1804            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_NeS(
1805                    long groupId, int status, int start, int end,
1806                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1807                    throws com.liferay.portal.kernel.exception.SystemException {
1808                    return getPersistence()
1809                                       .findByG_NeS(groupId, status, start, end, orderByComparator);
1810            }
1811    
1812            /**
1813            * Returns the first blogs entry in the ordered set where groupId = &#63; and status &ne; &#63;.
1814            *
1815            * @param groupId the group ID
1816            * @param status the status
1817            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1818            * @return the first matching blogs entry
1819            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1820            * @throws SystemException if a system exception occurred
1821            */
1822            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_NeS_First(
1823                    long groupId, int status,
1824                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1825                    throws com.liferay.portal.kernel.exception.SystemException,
1826                            com.liferay.portlet.blogs.NoSuchEntryException {
1827                    return getPersistence()
1828                                       .findByG_NeS_First(groupId, status, orderByComparator);
1829            }
1830    
1831            /**
1832            * Returns the first blogs entry in the ordered set where groupId = &#63; and status &ne; &#63;.
1833            *
1834            * @param groupId the group ID
1835            * @param status the status
1836            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1837            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
1838            * @throws SystemException if a system exception occurred
1839            */
1840            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_NeS_First(
1841                    long groupId, int status,
1842                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1843                    throws com.liferay.portal.kernel.exception.SystemException {
1844                    return getPersistence()
1845                                       .fetchByG_NeS_First(groupId, status, orderByComparator);
1846            }
1847    
1848            /**
1849            * Returns the last blogs entry in the ordered set where groupId = &#63; and status &ne; &#63;.
1850            *
1851            * @param groupId the group ID
1852            * @param status the status
1853            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1854            * @return the last matching blogs entry
1855            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1856            * @throws SystemException if a system exception occurred
1857            */
1858            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_NeS_Last(
1859                    long groupId, int status,
1860                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1861                    throws com.liferay.portal.kernel.exception.SystemException,
1862                            com.liferay.portlet.blogs.NoSuchEntryException {
1863                    return getPersistence()
1864                                       .findByG_NeS_Last(groupId, status, orderByComparator);
1865            }
1866    
1867            /**
1868            * Returns the last blogs entry in the ordered set where groupId = &#63; and status &ne; &#63;.
1869            *
1870            * @param groupId the group ID
1871            * @param status the status
1872            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1873            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
1874            * @throws SystemException if a system exception occurred
1875            */
1876            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_NeS_Last(
1877                    long groupId, int status,
1878                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1879                    throws com.liferay.portal.kernel.exception.SystemException {
1880                    return getPersistence()
1881                                       .fetchByG_NeS_Last(groupId, status, orderByComparator);
1882            }
1883    
1884            /**
1885            * Returns the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63; and status &ne; &#63;.
1886            *
1887            * @param entryId the primary key of the current blogs entry
1888            * @param groupId the group ID
1889            * @param status the status
1890            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1891            * @return the previous, current, and next blogs entry
1892            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
1893            * @throws SystemException if a system exception occurred
1894            */
1895            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByG_NeS_PrevAndNext(
1896                    long entryId, long groupId, int status,
1897                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1898                    throws com.liferay.portal.kernel.exception.SystemException,
1899                            com.liferay.portlet.blogs.NoSuchEntryException {
1900                    return getPersistence()
1901                                       .findByG_NeS_PrevAndNext(entryId, groupId, status,
1902                            orderByComparator);
1903            }
1904    
1905            /**
1906            * Returns all the blogs entries that the user has permission to view where groupId = &#63; and status &ne; &#63;.
1907            *
1908            * @param groupId the group ID
1909            * @param status the status
1910            * @return the matching blogs entries that the user has permission to view
1911            * @throws SystemException if a system exception occurred
1912            */
1913            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_NeS(
1914                    long groupId, int status)
1915                    throws com.liferay.portal.kernel.exception.SystemException {
1916                    return getPersistence().filterFindByG_NeS(groupId, status);
1917            }
1918    
1919            /**
1920            * Returns a range of all the blogs entries that the user has permission to view where groupId = &#63; and status &ne; &#63;.
1921            *
1922            * <p>
1923            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1924            * </p>
1925            *
1926            * @param groupId the group ID
1927            * @param status the status
1928            * @param start the lower bound of the range of blogs entries
1929            * @param end the upper bound of the range of blogs entries (not inclusive)
1930            * @return the range of matching blogs entries that the user has permission to view
1931            * @throws SystemException if a system exception occurred
1932            */
1933            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_NeS(
1934                    long groupId, int status, int start, int end)
1935                    throws com.liferay.portal.kernel.exception.SystemException {
1936                    return getPersistence().filterFindByG_NeS(groupId, status, start, end);
1937            }
1938    
1939            /**
1940            * Returns an ordered range of all the blogs entries that the user has permissions to view where groupId = &#63; and status &ne; &#63;.
1941            *
1942            * <p>
1943            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
1944            * </p>
1945            *
1946            * @param groupId the group ID
1947            * @param status the status
1948            * @param start the lower bound of the range of blogs entries
1949            * @param end the upper bound of the range of blogs entries (not inclusive)
1950            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
1951            * @return the ordered range of matching blogs entries that the user has permission to view
1952            * @throws SystemException if a system exception occurred
1953            */
1954            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_NeS(
1955                    long groupId, int status, int start, int end,
1956                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1957                    throws com.liferay.portal.kernel.exception.SystemException {
1958                    return getPersistence()
1959                                       .filterFindByG_NeS(groupId, status, start, end,
1960                            orderByComparator);
1961            }
1962    
1963            /**
1964            * Returns the blogs entries before and after the current blogs entry in the ordered set of blogs entries that the user has permission to view where groupId = &#63; and status &ne; &#63;.
1965            *
1966            * @param entryId the primary key of the current blogs entry
1967            * @param groupId the group ID
1968            * @param status the status
1969            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
1970            * @return the previous, current, and next blogs entry
1971            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
1972            * @throws SystemException if a system exception occurred
1973            */
1974            public static com.liferay.portlet.blogs.model.BlogsEntry[] filterFindByG_NeS_PrevAndNext(
1975                    long entryId, long groupId, int status,
1976                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1977                    throws com.liferay.portal.kernel.exception.SystemException,
1978                            com.liferay.portlet.blogs.NoSuchEntryException {
1979                    return getPersistence()
1980                                       .filterFindByG_NeS_PrevAndNext(entryId, groupId, status,
1981                            orderByComparator);
1982            }
1983    
1984            /**
1985            * Returns all the blogs entries where groupId = &#63; and status = &#63;.
1986            *
1987            * @param groupId the group ID
1988            * @param status the status
1989            * @return the matching blogs entries
1990            * @throws SystemException if a system exception occurred
1991            */
1992            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_S(
1993                    long groupId, int status)
1994                    throws com.liferay.portal.kernel.exception.SystemException {
1995                    return getPersistence().findByG_S(groupId, status);
1996            }
1997    
1998            /**
1999            * Returns a range of all the blogs entries where groupId = &#63; and status = &#63;.
2000            *
2001            * <p>
2002            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2003            * </p>
2004            *
2005            * @param groupId the group ID
2006            * @param status the status
2007            * @param start the lower bound of the range of blogs entries
2008            * @param end the upper bound of the range of blogs entries (not inclusive)
2009            * @return the range of matching blogs entries
2010            * @throws SystemException if a system exception occurred
2011            */
2012            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_S(
2013                    long groupId, int status, int start, int end)
2014                    throws com.liferay.portal.kernel.exception.SystemException {
2015                    return getPersistence().findByG_S(groupId, status, start, end);
2016            }
2017    
2018            /**
2019            * Returns an ordered range of all the blogs entries where groupId = &#63; and status = &#63;.
2020            *
2021            * <p>
2022            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2023            * </p>
2024            *
2025            * @param groupId the group ID
2026            * @param status the status
2027            * @param start the lower bound of the range of blogs entries
2028            * @param end the upper bound of the range of blogs entries (not inclusive)
2029            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2030            * @return the ordered range of matching blogs entries
2031            * @throws SystemException if a system exception occurred
2032            */
2033            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_S(
2034                    long groupId, int status, int start, int end,
2035                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2036                    throws com.liferay.portal.kernel.exception.SystemException {
2037                    return getPersistence()
2038                                       .findByG_S(groupId, status, start, end, orderByComparator);
2039            }
2040    
2041            /**
2042            * Returns the first blogs entry in the ordered set where groupId = &#63; and status = &#63;.
2043            *
2044            * @param groupId the group ID
2045            * @param status the status
2046            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2047            * @return the first matching blogs entry
2048            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
2049            * @throws SystemException if a system exception occurred
2050            */
2051            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_S_First(
2052                    long groupId, int status,
2053                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2054                    throws com.liferay.portal.kernel.exception.SystemException,
2055                            com.liferay.portlet.blogs.NoSuchEntryException {
2056                    return getPersistence()
2057                                       .findByG_S_First(groupId, status, orderByComparator);
2058            }
2059    
2060            /**
2061            * Returns the first blogs entry in the ordered set where groupId = &#63; and status = &#63;.
2062            *
2063            * @param groupId the group ID
2064            * @param status the status
2065            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2066            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
2067            * @throws SystemException if a system exception occurred
2068            */
2069            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_S_First(
2070                    long groupId, int status,
2071                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2072                    throws com.liferay.portal.kernel.exception.SystemException {
2073                    return getPersistence()
2074                                       .fetchByG_S_First(groupId, status, orderByComparator);
2075            }
2076    
2077            /**
2078            * Returns the last blogs entry in the ordered set where groupId = &#63; and status = &#63;.
2079            *
2080            * @param groupId the group ID
2081            * @param status the status
2082            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2083            * @return the last matching blogs entry
2084            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
2085            * @throws SystemException if a system exception occurred
2086            */
2087            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_S_Last(
2088                    long groupId, int status,
2089                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2090                    throws com.liferay.portal.kernel.exception.SystemException,
2091                            com.liferay.portlet.blogs.NoSuchEntryException {
2092                    return getPersistence()
2093                                       .findByG_S_Last(groupId, status, orderByComparator);
2094            }
2095    
2096            /**
2097            * Returns the last blogs entry in the ordered set where groupId = &#63; and status = &#63;.
2098            *
2099            * @param groupId the group ID
2100            * @param status the status
2101            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2102            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
2103            * @throws SystemException if a system exception occurred
2104            */
2105            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_S_Last(
2106                    long groupId, int status,
2107                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2108                    throws com.liferay.portal.kernel.exception.SystemException {
2109                    return getPersistence()
2110                                       .fetchByG_S_Last(groupId, status, orderByComparator);
2111            }
2112    
2113            /**
2114            * Returns the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63; and status = &#63;.
2115            *
2116            * @param entryId the primary key of the current blogs entry
2117            * @param groupId the group ID
2118            * @param status the status
2119            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2120            * @return the previous, current, and next blogs entry
2121            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
2122            * @throws SystemException if a system exception occurred
2123            */
2124            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByG_S_PrevAndNext(
2125                    long entryId, long groupId, int status,
2126                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2127                    throws com.liferay.portal.kernel.exception.SystemException,
2128                            com.liferay.portlet.blogs.NoSuchEntryException {
2129                    return getPersistence()
2130                                       .findByG_S_PrevAndNext(entryId, groupId, status,
2131                            orderByComparator);
2132            }
2133    
2134            /**
2135            * Returns all the blogs entries that the user has permission to view where groupId = &#63; and status = &#63;.
2136            *
2137            * @param groupId the group ID
2138            * @param status the status
2139            * @return the matching blogs entries that the user has permission to view
2140            * @throws SystemException if a system exception occurred
2141            */
2142            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_S(
2143                    long groupId, int status)
2144                    throws com.liferay.portal.kernel.exception.SystemException {
2145                    return getPersistence().filterFindByG_S(groupId, status);
2146            }
2147    
2148            /**
2149            * Returns a range of all the blogs entries that the user has permission to view where groupId = &#63; and status = &#63;.
2150            *
2151            * <p>
2152            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2153            * </p>
2154            *
2155            * @param groupId the group ID
2156            * @param status the status
2157            * @param start the lower bound of the range of blogs entries
2158            * @param end the upper bound of the range of blogs entries (not inclusive)
2159            * @return the range of matching blogs entries that the user has permission to view
2160            * @throws SystemException if a system exception occurred
2161            */
2162            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_S(
2163                    long groupId, int status, int start, int end)
2164                    throws com.liferay.portal.kernel.exception.SystemException {
2165                    return getPersistence().filterFindByG_S(groupId, status, start, end);
2166            }
2167    
2168            /**
2169            * Returns an ordered range of all the blogs entries that the user has permissions to view where groupId = &#63; and status = &#63;.
2170            *
2171            * <p>
2172            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2173            * </p>
2174            *
2175            * @param groupId the group ID
2176            * @param status the status
2177            * @param start the lower bound of the range of blogs entries
2178            * @param end the upper bound of the range of blogs entries (not inclusive)
2179            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2180            * @return the ordered range of matching blogs entries that the user has permission to view
2181            * @throws SystemException if a system exception occurred
2182            */
2183            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_S(
2184                    long groupId, int status, int start, int end,
2185                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2186                    throws com.liferay.portal.kernel.exception.SystemException {
2187                    return getPersistence()
2188                                       .filterFindByG_S(groupId, status, start, end,
2189                            orderByComparator);
2190            }
2191    
2192            /**
2193            * Returns the blogs entries before and after the current blogs entry in the ordered set of blogs entries that the user has permission to view where groupId = &#63; and status = &#63;.
2194            *
2195            * @param entryId the primary key of the current blogs entry
2196            * @param groupId the group ID
2197            * @param status the status
2198            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2199            * @return the previous, current, and next blogs entry
2200            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
2201            * @throws SystemException if a system exception occurred
2202            */
2203            public static com.liferay.portlet.blogs.model.BlogsEntry[] filterFindByG_S_PrevAndNext(
2204                    long entryId, long groupId, int status,
2205                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2206                    throws com.liferay.portal.kernel.exception.SystemException,
2207                            com.liferay.portlet.blogs.NoSuchEntryException {
2208                    return getPersistence()
2209                                       .filterFindByG_S_PrevAndNext(entryId, groupId, status,
2210                            orderByComparator);
2211            }
2212    
2213            /**
2214            * Returns all the blogs entries where displayDate &lt; &#63; and status = &#63;.
2215            *
2216            * @param displayDate the display date
2217            * @param status the status
2218            * @return the matching blogs entries
2219            * @throws SystemException if a system exception occurred
2220            */
2221            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByLtD_S(
2222                    java.util.Date displayDate, int status)
2223                    throws com.liferay.portal.kernel.exception.SystemException {
2224                    return getPersistence().findByLtD_S(displayDate, status);
2225            }
2226    
2227            /**
2228            * Returns a range of all the blogs entries where displayDate &lt; &#63; and status = &#63;.
2229            *
2230            * <p>
2231            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2232            * </p>
2233            *
2234            * @param displayDate the display date
2235            * @param status the status
2236            * @param start the lower bound of the range of blogs entries
2237            * @param end the upper bound of the range of blogs entries (not inclusive)
2238            * @return the range of matching blogs entries
2239            * @throws SystemException if a system exception occurred
2240            */
2241            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByLtD_S(
2242                    java.util.Date displayDate, int status, int start, int end)
2243                    throws com.liferay.portal.kernel.exception.SystemException {
2244                    return getPersistence().findByLtD_S(displayDate, status, start, end);
2245            }
2246    
2247            /**
2248            * Returns an ordered range of all the blogs entries where displayDate &lt; &#63; and status = &#63;.
2249            *
2250            * <p>
2251            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2252            * </p>
2253            *
2254            * @param displayDate the display date
2255            * @param status the status
2256            * @param start the lower bound of the range of blogs entries
2257            * @param end the upper bound of the range of blogs entries (not inclusive)
2258            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2259            * @return the ordered range of matching blogs entries
2260            * @throws SystemException if a system exception occurred
2261            */
2262            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByLtD_S(
2263                    java.util.Date displayDate, int status, int start, int end,
2264                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2265                    throws com.liferay.portal.kernel.exception.SystemException {
2266                    return getPersistence()
2267                                       .findByLtD_S(displayDate, status, start, end,
2268                            orderByComparator);
2269            }
2270    
2271            /**
2272            * Returns the first blogs entry in the ordered set where displayDate &lt; &#63; and status = &#63;.
2273            *
2274            * @param displayDate the display date
2275            * @param status the status
2276            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2277            * @return the first matching blogs entry
2278            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
2279            * @throws SystemException if a system exception occurred
2280            */
2281            public static com.liferay.portlet.blogs.model.BlogsEntry findByLtD_S_First(
2282                    java.util.Date displayDate, int status,
2283                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2284                    throws com.liferay.portal.kernel.exception.SystemException,
2285                            com.liferay.portlet.blogs.NoSuchEntryException {
2286                    return getPersistence()
2287                                       .findByLtD_S_First(displayDate, status, orderByComparator);
2288            }
2289    
2290            /**
2291            * Returns the first blogs entry in the ordered set where displayDate &lt; &#63; and status = &#63;.
2292            *
2293            * @param displayDate the display date
2294            * @param status the status
2295            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2296            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
2297            * @throws SystemException if a system exception occurred
2298            */
2299            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByLtD_S_First(
2300                    java.util.Date displayDate, int status,
2301                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2302                    throws com.liferay.portal.kernel.exception.SystemException {
2303                    return getPersistence()
2304                                       .fetchByLtD_S_First(displayDate, status, orderByComparator);
2305            }
2306    
2307            /**
2308            * Returns the last blogs entry in the ordered set where displayDate &lt; &#63; and status = &#63;.
2309            *
2310            * @param displayDate the display date
2311            * @param status the status
2312            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2313            * @return the last matching blogs entry
2314            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
2315            * @throws SystemException if a system exception occurred
2316            */
2317            public static com.liferay.portlet.blogs.model.BlogsEntry findByLtD_S_Last(
2318                    java.util.Date displayDate, int status,
2319                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2320                    throws com.liferay.portal.kernel.exception.SystemException,
2321                            com.liferay.portlet.blogs.NoSuchEntryException {
2322                    return getPersistence()
2323                                       .findByLtD_S_Last(displayDate, status, orderByComparator);
2324            }
2325    
2326            /**
2327            * Returns the last blogs entry in the ordered set where displayDate &lt; &#63; and status = &#63;.
2328            *
2329            * @param displayDate the display date
2330            * @param status the status
2331            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2332            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
2333            * @throws SystemException if a system exception occurred
2334            */
2335            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByLtD_S_Last(
2336                    java.util.Date displayDate, int status,
2337                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2338                    throws com.liferay.portal.kernel.exception.SystemException {
2339                    return getPersistence()
2340                                       .fetchByLtD_S_Last(displayDate, status, orderByComparator);
2341            }
2342    
2343            /**
2344            * Returns the blogs entries before and after the current blogs entry in the ordered set where displayDate &lt; &#63; and status = &#63;.
2345            *
2346            * @param entryId the primary key of the current blogs entry
2347            * @param displayDate the display date
2348            * @param status the status
2349            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2350            * @return the previous, current, and next blogs entry
2351            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
2352            * @throws SystemException if a system exception occurred
2353            */
2354            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByLtD_S_PrevAndNext(
2355                    long entryId, java.util.Date displayDate, int status,
2356                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2357                    throws com.liferay.portal.kernel.exception.SystemException,
2358                            com.liferay.portlet.blogs.NoSuchEntryException {
2359                    return getPersistence()
2360                                       .findByLtD_S_PrevAndNext(entryId, displayDate, status,
2361                            orderByComparator);
2362            }
2363    
2364            /**
2365            * Returns all the blogs entries where companyId = &#63; and userId = &#63; and status &ne; &#63;.
2366            *
2367            * @param companyId the company ID
2368            * @param userId the user ID
2369            * @param status the status
2370            * @return the matching blogs entries
2371            * @throws SystemException if a system exception occurred
2372            */
2373            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_U_NeS(
2374                    long companyId, long userId, int status)
2375                    throws com.liferay.portal.kernel.exception.SystemException {
2376                    return getPersistence().findByC_U_NeS(companyId, userId, status);
2377            }
2378    
2379            /**
2380            * Returns a range of all the blogs entries where companyId = &#63; and userId = &#63; and status &ne; &#63;.
2381            *
2382            * <p>
2383            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2384            * </p>
2385            *
2386            * @param companyId the company ID
2387            * @param userId the user ID
2388            * @param status the status
2389            * @param start the lower bound of the range of blogs entries
2390            * @param end the upper bound of the range of blogs entries (not inclusive)
2391            * @return the range of matching blogs entries
2392            * @throws SystemException if a system exception occurred
2393            */
2394            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_U_NeS(
2395                    long companyId, long userId, int status, int start, int end)
2396                    throws com.liferay.portal.kernel.exception.SystemException {
2397                    return getPersistence()
2398                                       .findByC_U_NeS(companyId, userId, status, start, end);
2399            }
2400    
2401            /**
2402            * Returns an ordered range of all the blogs entries where companyId = &#63; and userId = &#63; and status &ne; &#63;.
2403            *
2404            * <p>
2405            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2406            * </p>
2407            *
2408            * @param companyId the company ID
2409            * @param userId the user ID
2410            * @param status the status
2411            * @param start the lower bound of the range of blogs entries
2412            * @param end the upper bound of the range of blogs entries (not inclusive)
2413            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2414            * @return the ordered range of matching blogs entries
2415            * @throws SystemException if a system exception occurred
2416            */
2417            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_U_NeS(
2418                    long companyId, long userId, int status, int start, int end,
2419                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2420                    throws com.liferay.portal.kernel.exception.SystemException {
2421                    return getPersistence()
2422                                       .findByC_U_NeS(companyId, userId, status, start, end,
2423                            orderByComparator);
2424            }
2425    
2426            /**
2427            * Returns the first blogs entry in the ordered set where companyId = &#63; and userId = &#63; and status &ne; &#63;.
2428            *
2429            * @param companyId the company ID
2430            * @param userId the user ID
2431            * @param status the status
2432            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2433            * @return the first matching blogs entry
2434            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
2435            * @throws SystemException if a system exception occurred
2436            */
2437            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_U_NeS_First(
2438                    long companyId, long userId, int status,
2439                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2440                    throws com.liferay.portal.kernel.exception.SystemException,
2441                            com.liferay.portlet.blogs.NoSuchEntryException {
2442                    return getPersistence()
2443                                       .findByC_U_NeS_First(companyId, userId, status,
2444                            orderByComparator);
2445            }
2446    
2447            /**
2448            * Returns the first blogs entry in the ordered set where companyId = &#63; and userId = &#63; and status &ne; &#63;.
2449            *
2450            * @param companyId the company ID
2451            * @param userId the user ID
2452            * @param status the status
2453            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2454            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
2455            * @throws SystemException if a system exception occurred
2456            */
2457            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByC_U_NeS_First(
2458                    long companyId, long userId, int status,
2459                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2460                    throws com.liferay.portal.kernel.exception.SystemException {
2461                    return getPersistence()
2462                                       .fetchByC_U_NeS_First(companyId, userId, status,
2463                            orderByComparator);
2464            }
2465    
2466            /**
2467            * Returns the last blogs entry in the ordered set where companyId = &#63; and userId = &#63; and status &ne; &#63;.
2468            *
2469            * @param companyId the company ID
2470            * @param userId the user ID
2471            * @param status the status
2472            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2473            * @return the last matching blogs entry
2474            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
2475            * @throws SystemException if a system exception occurred
2476            */
2477            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_U_NeS_Last(
2478                    long companyId, long userId, int status,
2479                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2480                    throws com.liferay.portal.kernel.exception.SystemException,
2481                            com.liferay.portlet.blogs.NoSuchEntryException {
2482                    return getPersistence()
2483                                       .findByC_U_NeS_Last(companyId, userId, status,
2484                            orderByComparator);
2485            }
2486    
2487            /**
2488            * Returns the last blogs entry in the ordered set where companyId = &#63; and userId = &#63; and status &ne; &#63;.
2489            *
2490            * @param companyId the company ID
2491            * @param userId the user ID
2492            * @param status the status
2493            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2494            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
2495            * @throws SystemException if a system exception occurred
2496            */
2497            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByC_U_NeS_Last(
2498                    long companyId, long userId, int status,
2499                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2500                    throws com.liferay.portal.kernel.exception.SystemException {
2501                    return getPersistence()
2502                                       .fetchByC_U_NeS_Last(companyId, userId, status,
2503                            orderByComparator);
2504            }
2505    
2506            /**
2507            * Returns the blogs entries before and after the current blogs entry in the ordered set where companyId = &#63; and userId = &#63; and status &ne; &#63;.
2508            *
2509            * @param entryId the primary key of the current blogs entry
2510            * @param companyId the company ID
2511            * @param userId the user ID
2512            * @param status the status
2513            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2514            * @return the previous, current, and next blogs entry
2515            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
2516            * @throws SystemException if a system exception occurred
2517            */
2518            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByC_U_NeS_PrevAndNext(
2519                    long entryId, long companyId, long userId, int status,
2520                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2521                    throws com.liferay.portal.kernel.exception.SystemException,
2522                            com.liferay.portlet.blogs.NoSuchEntryException {
2523                    return getPersistence()
2524                                       .findByC_U_NeS_PrevAndNext(entryId, companyId, userId,
2525                            status, orderByComparator);
2526            }
2527    
2528            /**
2529            * Returns all the blogs entries where companyId = &#63; and userId = &#63; and status = &#63;.
2530            *
2531            * @param companyId the company ID
2532            * @param userId the user ID
2533            * @param status the status
2534            * @return the matching blogs entries
2535            * @throws SystemException if a system exception occurred
2536            */
2537            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_U_S(
2538                    long companyId, long userId, int status)
2539                    throws com.liferay.portal.kernel.exception.SystemException {
2540                    return getPersistence().findByC_U_S(companyId, userId, status);
2541            }
2542    
2543            /**
2544            * Returns a range of all the blogs entries where companyId = &#63; and userId = &#63; and status = &#63;.
2545            *
2546            * <p>
2547            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2548            * </p>
2549            *
2550            * @param companyId the company ID
2551            * @param userId the user ID
2552            * @param status the status
2553            * @param start the lower bound of the range of blogs entries
2554            * @param end the upper bound of the range of blogs entries (not inclusive)
2555            * @return the range of matching blogs entries
2556            * @throws SystemException if a system exception occurred
2557            */
2558            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_U_S(
2559                    long companyId, long userId, int status, int start, int end)
2560                    throws com.liferay.portal.kernel.exception.SystemException {
2561                    return getPersistence()
2562                                       .findByC_U_S(companyId, userId, status, start, end);
2563            }
2564    
2565            /**
2566            * Returns an ordered range of all the blogs entries where companyId = &#63; and userId = &#63; and status = &#63;.
2567            *
2568            * <p>
2569            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2570            * </p>
2571            *
2572            * @param companyId the company ID
2573            * @param userId the user ID
2574            * @param status the status
2575            * @param start the lower bound of the range of blogs entries
2576            * @param end the upper bound of the range of blogs entries (not inclusive)
2577            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2578            * @return the ordered range of matching blogs entries
2579            * @throws SystemException if a system exception occurred
2580            */
2581            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_U_S(
2582                    long companyId, long userId, int status, int start, int end,
2583                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2584                    throws com.liferay.portal.kernel.exception.SystemException {
2585                    return getPersistence()
2586                                       .findByC_U_S(companyId, userId, status, start, end,
2587                            orderByComparator);
2588            }
2589    
2590            /**
2591            * Returns the first blogs entry in the ordered set where companyId = &#63; and userId = &#63; and status = &#63;.
2592            *
2593            * @param companyId the company ID
2594            * @param userId the user ID
2595            * @param status the status
2596            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2597            * @return the first matching blogs entry
2598            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
2599            * @throws SystemException if a system exception occurred
2600            */
2601            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_U_S_First(
2602                    long companyId, long userId, int status,
2603                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2604                    throws com.liferay.portal.kernel.exception.SystemException,
2605                            com.liferay.portlet.blogs.NoSuchEntryException {
2606                    return getPersistence()
2607                                       .findByC_U_S_First(companyId, userId, status,
2608                            orderByComparator);
2609            }
2610    
2611            /**
2612            * Returns the first blogs entry in the ordered set where companyId = &#63; and userId = &#63; and status = &#63;.
2613            *
2614            * @param companyId the company ID
2615            * @param userId the user ID
2616            * @param status the status
2617            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2618            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
2619            * @throws SystemException if a system exception occurred
2620            */
2621            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByC_U_S_First(
2622                    long companyId, long userId, int status,
2623                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2624                    throws com.liferay.portal.kernel.exception.SystemException {
2625                    return getPersistence()
2626                                       .fetchByC_U_S_First(companyId, userId, status,
2627                            orderByComparator);
2628            }
2629    
2630            /**
2631            * Returns the last blogs entry in the ordered set where companyId = &#63; and userId = &#63; and status = &#63;.
2632            *
2633            * @param companyId the company ID
2634            * @param userId the user ID
2635            * @param status the status
2636            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2637            * @return the last matching blogs entry
2638            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
2639            * @throws SystemException if a system exception occurred
2640            */
2641            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_U_S_Last(
2642                    long companyId, long userId, int status,
2643                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2644                    throws com.liferay.portal.kernel.exception.SystemException,
2645                            com.liferay.portlet.blogs.NoSuchEntryException {
2646                    return getPersistence()
2647                                       .findByC_U_S_Last(companyId, userId, status,
2648                            orderByComparator);
2649            }
2650    
2651            /**
2652            * Returns the last blogs entry in the ordered set where companyId = &#63; and userId = &#63; and status = &#63;.
2653            *
2654            * @param companyId the company ID
2655            * @param userId the user ID
2656            * @param status the status
2657            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2658            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
2659            * @throws SystemException if a system exception occurred
2660            */
2661            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByC_U_S_Last(
2662                    long companyId, long userId, int status,
2663                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2664                    throws com.liferay.portal.kernel.exception.SystemException {
2665                    return getPersistence()
2666                                       .fetchByC_U_S_Last(companyId, userId, status,
2667                            orderByComparator);
2668            }
2669    
2670            /**
2671            * Returns the blogs entries before and after the current blogs entry in the ordered set where companyId = &#63; and userId = &#63; and status = &#63;.
2672            *
2673            * @param entryId the primary key of the current blogs entry
2674            * @param companyId the company ID
2675            * @param userId the user ID
2676            * @param status the status
2677            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2678            * @return the previous, current, and next blogs entry
2679            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
2680            * @throws SystemException if a system exception occurred
2681            */
2682            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByC_U_S_PrevAndNext(
2683                    long entryId, long companyId, long userId, int status,
2684                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2685                    throws com.liferay.portal.kernel.exception.SystemException,
2686                            com.liferay.portlet.blogs.NoSuchEntryException {
2687                    return getPersistence()
2688                                       .findByC_U_S_PrevAndNext(entryId, companyId, userId, status,
2689                            orderByComparator);
2690            }
2691    
2692            /**
2693            * Returns all the blogs entries where companyId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
2694            *
2695            * @param companyId the company ID
2696            * @param displayDate the display date
2697            * @param status the status
2698            * @return the matching blogs entries
2699            * @throws SystemException if a system exception occurred
2700            */
2701            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_LtD_NeS(
2702                    long companyId, java.util.Date displayDate, int status)
2703                    throws com.liferay.portal.kernel.exception.SystemException {
2704                    return getPersistence().findByC_LtD_NeS(companyId, displayDate, status);
2705            }
2706    
2707            /**
2708            * Returns a range of all the blogs entries where companyId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
2709            *
2710            * <p>
2711            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2712            * </p>
2713            *
2714            * @param companyId the company ID
2715            * @param displayDate the display date
2716            * @param status the status
2717            * @param start the lower bound of the range of blogs entries
2718            * @param end the upper bound of the range of blogs entries (not inclusive)
2719            * @return the range of matching blogs entries
2720            * @throws SystemException if a system exception occurred
2721            */
2722            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_LtD_NeS(
2723                    long companyId, java.util.Date displayDate, int status, int start,
2724                    int end) throws com.liferay.portal.kernel.exception.SystemException {
2725                    return getPersistence()
2726                                       .findByC_LtD_NeS(companyId, displayDate, status, start, end);
2727            }
2728    
2729            /**
2730            * Returns an ordered range of all the blogs entries where companyId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
2731            *
2732            * <p>
2733            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2734            * </p>
2735            *
2736            * @param companyId the company ID
2737            * @param displayDate the display date
2738            * @param status the status
2739            * @param start the lower bound of the range of blogs entries
2740            * @param end the upper bound of the range of blogs entries (not inclusive)
2741            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2742            * @return the ordered range of matching blogs entries
2743            * @throws SystemException if a system exception occurred
2744            */
2745            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_LtD_NeS(
2746                    long companyId, java.util.Date displayDate, int status, int start,
2747                    int end,
2748                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2749                    throws com.liferay.portal.kernel.exception.SystemException {
2750                    return getPersistence()
2751                                       .findByC_LtD_NeS(companyId, displayDate, status, start, end,
2752                            orderByComparator);
2753            }
2754    
2755            /**
2756            * Returns the first blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
2757            *
2758            * @param companyId the company ID
2759            * @param displayDate the display date
2760            * @param status the status
2761            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2762            * @return the first matching blogs entry
2763            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
2764            * @throws SystemException if a system exception occurred
2765            */
2766            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_LtD_NeS_First(
2767                    long companyId, java.util.Date displayDate, int status,
2768                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2769                    throws com.liferay.portal.kernel.exception.SystemException,
2770                            com.liferay.portlet.blogs.NoSuchEntryException {
2771                    return getPersistence()
2772                                       .findByC_LtD_NeS_First(companyId, displayDate, status,
2773                            orderByComparator);
2774            }
2775    
2776            /**
2777            * Returns the first blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
2778            *
2779            * @param companyId the company ID
2780            * @param displayDate the display date
2781            * @param status the status
2782            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2783            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
2784            * @throws SystemException if a system exception occurred
2785            */
2786            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByC_LtD_NeS_First(
2787                    long companyId, java.util.Date displayDate, int status,
2788                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2789                    throws com.liferay.portal.kernel.exception.SystemException {
2790                    return getPersistence()
2791                                       .fetchByC_LtD_NeS_First(companyId, displayDate, status,
2792                            orderByComparator);
2793            }
2794    
2795            /**
2796            * Returns the last blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
2797            *
2798            * @param companyId the company ID
2799            * @param displayDate the display date
2800            * @param status the status
2801            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2802            * @return the last matching blogs entry
2803            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
2804            * @throws SystemException if a system exception occurred
2805            */
2806            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_LtD_NeS_Last(
2807                    long companyId, java.util.Date displayDate, int status,
2808                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2809                    throws com.liferay.portal.kernel.exception.SystemException,
2810                            com.liferay.portlet.blogs.NoSuchEntryException {
2811                    return getPersistence()
2812                                       .findByC_LtD_NeS_Last(companyId, displayDate, status,
2813                            orderByComparator);
2814            }
2815    
2816            /**
2817            * Returns the last blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
2818            *
2819            * @param companyId the company ID
2820            * @param displayDate the display date
2821            * @param status the status
2822            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2823            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
2824            * @throws SystemException if a system exception occurred
2825            */
2826            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByC_LtD_NeS_Last(
2827                    long companyId, java.util.Date displayDate, int status,
2828                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2829                    throws com.liferay.portal.kernel.exception.SystemException {
2830                    return getPersistence()
2831                                       .fetchByC_LtD_NeS_Last(companyId, displayDate, status,
2832                            orderByComparator);
2833            }
2834    
2835            /**
2836            * Returns the blogs entries before and after the current blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
2837            *
2838            * @param entryId the primary key of the current blogs entry
2839            * @param companyId the company ID
2840            * @param displayDate the display date
2841            * @param status the status
2842            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2843            * @return the previous, current, and next blogs entry
2844            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
2845            * @throws SystemException if a system exception occurred
2846            */
2847            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByC_LtD_NeS_PrevAndNext(
2848                    long entryId, long companyId, java.util.Date displayDate, int status,
2849                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2850                    throws com.liferay.portal.kernel.exception.SystemException,
2851                            com.liferay.portlet.blogs.NoSuchEntryException {
2852                    return getPersistence()
2853                                       .findByC_LtD_NeS_PrevAndNext(entryId, companyId,
2854                            displayDate, status, orderByComparator);
2855            }
2856    
2857            /**
2858            * Returns all the blogs entries where companyId = &#63; and displayDate &lt; &#63; and status = &#63;.
2859            *
2860            * @param companyId the company ID
2861            * @param displayDate the display date
2862            * @param status the status
2863            * @return the matching blogs entries
2864            * @throws SystemException if a system exception occurred
2865            */
2866            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_LtD_S(
2867                    long companyId, java.util.Date displayDate, int status)
2868                    throws com.liferay.portal.kernel.exception.SystemException {
2869                    return getPersistence().findByC_LtD_S(companyId, displayDate, status);
2870            }
2871    
2872            /**
2873            * Returns a range of all the blogs entries where companyId = &#63; and displayDate &lt; &#63; and status = &#63;.
2874            *
2875            * <p>
2876            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2877            * </p>
2878            *
2879            * @param companyId the company ID
2880            * @param displayDate the display date
2881            * @param status the status
2882            * @param start the lower bound of the range of blogs entries
2883            * @param end the upper bound of the range of blogs entries (not inclusive)
2884            * @return the range of matching blogs entries
2885            * @throws SystemException if a system exception occurred
2886            */
2887            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_LtD_S(
2888                    long companyId, java.util.Date displayDate, int status, int start,
2889                    int end) throws com.liferay.portal.kernel.exception.SystemException {
2890                    return getPersistence()
2891                                       .findByC_LtD_S(companyId, displayDate, status, start, end);
2892            }
2893    
2894            /**
2895            * Returns an ordered range of all the blogs entries where companyId = &#63; and displayDate &lt; &#63; and status = &#63;.
2896            *
2897            * <p>
2898            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
2899            * </p>
2900            *
2901            * @param companyId the company ID
2902            * @param displayDate the display date
2903            * @param status the status
2904            * @param start the lower bound of the range of blogs entries
2905            * @param end the upper bound of the range of blogs entries (not inclusive)
2906            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
2907            * @return the ordered range of matching blogs entries
2908            * @throws SystemException if a system exception occurred
2909            */
2910            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_LtD_S(
2911                    long companyId, java.util.Date displayDate, int status, int start,
2912                    int end,
2913                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2914                    throws com.liferay.portal.kernel.exception.SystemException {
2915                    return getPersistence()
2916                                       .findByC_LtD_S(companyId, displayDate, status, start, end,
2917                            orderByComparator);
2918            }
2919    
2920            /**
2921            * Returns the first blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63; and status = &#63;.
2922            *
2923            * @param companyId the company ID
2924            * @param displayDate the display date
2925            * @param status the status
2926            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2927            * @return the first matching blogs entry
2928            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
2929            * @throws SystemException if a system exception occurred
2930            */
2931            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_LtD_S_First(
2932                    long companyId, java.util.Date displayDate, int status,
2933                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2934                    throws com.liferay.portal.kernel.exception.SystemException,
2935                            com.liferay.portlet.blogs.NoSuchEntryException {
2936                    return getPersistence()
2937                                       .findByC_LtD_S_First(companyId, displayDate, status,
2938                            orderByComparator);
2939            }
2940    
2941            /**
2942            * Returns the first blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63; and status = &#63;.
2943            *
2944            * @param companyId the company ID
2945            * @param displayDate the display date
2946            * @param status the status
2947            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2948            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
2949            * @throws SystemException if a system exception occurred
2950            */
2951            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByC_LtD_S_First(
2952                    long companyId, java.util.Date displayDate, int status,
2953                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2954                    throws com.liferay.portal.kernel.exception.SystemException {
2955                    return getPersistence()
2956                                       .fetchByC_LtD_S_First(companyId, displayDate, status,
2957                            orderByComparator);
2958            }
2959    
2960            /**
2961            * Returns the last blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63; and status = &#63;.
2962            *
2963            * @param companyId the company ID
2964            * @param displayDate the display date
2965            * @param status the status
2966            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2967            * @return the last matching blogs entry
2968            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
2969            * @throws SystemException if a system exception occurred
2970            */
2971            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_LtD_S_Last(
2972                    long companyId, java.util.Date displayDate, int status,
2973                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2974                    throws com.liferay.portal.kernel.exception.SystemException,
2975                            com.liferay.portlet.blogs.NoSuchEntryException {
2976                    return getPersistence()
2977                                       .findByC_LtD_S_Last(companyId, displayDate, status,
2978                            orderByComparator);
2979            }
2980    
2981            /**
2982            * Returns the last blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63; and status = &#63;.
2983            *
2984            * @param companyId the company ID
2985            * @param displayDate the display date
2986            * @param status the status
2987            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
2988            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
2989            * @throws SystemException if a system exception occurred
2990            */
2991            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByC_LtD_S_Last(
2992                    long companyId, java.util.Date displayDate, int status,
2993                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2994                    throws com.liferay.portal.kernel.exception.SystemException {
2995                    return getPersistence()
2996                                       .fetchByC_LtD_S_Last(companyId, displayDate, status,
2997                            orderByComparator);
2998            }
2999    
3000            /**
3001            * Returns the blogs entries before and after the current blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63; and status = &#63;.
3002            *
3003            * @param entryId the primary key of the current blogs entry
3004            * @param companyId the company ID
3005            * @param displayDate the display date
3006            * @param status the status
3007            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3008            * @return the previous, current, and next blogs entry
3009            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
3010            * @throws SystemException if a system exception occurred
3011            */
3012            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByC_LtD_S_PrevAndNext(
3013                    long entryId, long companyId, java.util.Date displayDate, int status,
3014                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3015                    throws com.liferay.portal.kernel.exception.SystemException,
3016                            com.liferay.portlet.blogs.NoSuchEntryException {
3017                    return getPersistence()
3018                                       .findByC_LtD_S_PrevAndNext(entryId, companyId, displayDate,
3019                            status, orderByComparator);
3020            }
3021    
3022            /**
3023            * Returns all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
3024            *
3025            * @param groupId the group ID
3026            * @param userId the user ID
3027            * @param displayDate the display date
3028            * @return the matching blogs entries
3029            * @throws SystemException if a system exception occurred
3030            */
3031            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_LtD(
3032                    long groupId, long userId, java.util.Date displayDate)
3033                    throws com.liferay.portal.kernel.exception.SystemException {
3034                    return getPersistence().findByG_U_LtD(groupId, userId, displayDate);
3035            }
3036    
3037            /**
3038            * Returns a range of all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
3039            *
3040            * <p>
3041            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3042            * </p>
3043            *
3044            * @param groupId the group ID
3045            * @param userId the user ID
3046            * @param displayDate the display date
3047            * @param start the lower bound of the range of blogs entries
3048            * @param end the upper bound of the range of blogs entries (not inclusive)
3049            * @return the range of matching blogs entries
3050            * @throws SystemException if a system exception occurred
3051            */
3052            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_LtD(
3053                    long groupId, long userId, java.util.Date displayDate, int start,
3054                    int end) throws com.liferay.portal.kernel.exception.SystemException {
3055                    return getPersistence()
3056                                       .findByG_U_LtD(groupId, userId, displayDate, start, end);
3057            }
3058    
3059            /**
3060            * Returns an ordered range of all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
3061            *
3062            * <p>
3063            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3064            * </p>
3065            *
3066            * @param groupId the group ID
3067            * @param userId the user ID
3068            * @param displayDate the display date
3069            * @param start the lower bound of the range of blogs entries
3070            * @param end the upper bound of the range of blogs entries (not inclusive)
3071            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3072            * @return the ordered range of matching blogs entries
3073            * @throws SystemException if a system exception occurred
3074            */
3075            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_LtD(
3076                    long groupId, long userId, java.util.Date displayDate, int start,
3077                    int end,
3078                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3079                    throws com.liferay.portal.kernel.exception.SystemException {
3080                    return getPersistence()
3081                                       .findByG_U_LtD(groupId, userId, displayDate, start, end,
3082                            orderByComparator);
3083            }
3084    
3085            /**
3086            * Returns the first blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
3087            *
3088            * @param groupId the group ID
3089            * @param userId the user ID
3090            * @param displayDate the display date
3091            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3092            * @return the first matching blogs entry
3093            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
3094            * @throws SystemException if a system exception occurred
3095            */
3096            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_U_LtD_First(
3097                    long groupId, long userId, java.util.Date displayDate,
3098                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3099                    throws com.liferay.portal.kernel.exception.SystemException,
3100                            com.liferay.portlet.blogs.NoSuchEntryException {
3101                    return getPersistence()
3102                                       .findByG_U_LtD_First(groupId, userId, displayDate,
3103                            orderByComparator);
3104            }
3105    
3106            /**
3107            * Returns the first blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
3108            *
3109            * @param groupId the group ID
3110            * @param userId the user ID
3111            * @param displayDate the display date
3112            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3113            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
3114            * @throws SystemException if a system exception occurred
3115            */
3116            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_U_LtD_First(
3117                    long groupId, long userId, java.util.Date displayDate,
3118                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3119                    throws com.liferay.portal.kernel.exception.SystemException {
3120                    return getPersistence()
3121                                       .fetchByG_U_LtD_First(groupId, userId, displayDate,
3122                            orderByComparator);
3123            }
3124    
3125            /**
3126            * Returns the last blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
3127            *
3128            * @param groupId the group ID
3129            * @param userId the user ID
3130            * @param displayDate the display date
3131            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3132            * @return the last matching blogs entry
3133            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
3134            * @throws SystemException if a system exception occurred
3135            */
3136            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_U_LtD_Last(
3137                    long groupId, long userId, java.util.Date displayDate,
3138                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3139                    throws com.liferay.portal.kernel.exception.SystemException,
3140                            com.liferay.portlet.blogs.NoSuchEntryException {
3141                    return getPersistence()
3142                                       .findByG_U_LtD_Last(groupId, userId, displayDate,
3143                            orderByComparator);
3144            }
3145    
3146            /**
3147            * Returns the last blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
3148            *
3149            * @param groupId the group ID
3150            * @param userId the user ID
3151            * @param displayDate the display date
3152            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3153            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
3154            * @throws SystemException if a system exception occurred
3155            */
3156            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_U_LtD_Last(
3157                    long groupId, long userId, java.util.Date displayDate,
3158                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3159                    throws com.liferay.portal.kernel.exception.SystemException {
3160                    return getPersistence()
3161                                       .fetchByG_U_LtD_Last(groupId, userId, displayDate,
3162                            orderByComparator);
3163            }
3164    
3165            /**
3166            * Returns the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
3167            *
3168            * @param entryId the primary key of the current blogs entry
3169            * @param groupId the group ID
3170            * @param userId the user ID
3171            * @param displayDate the display date
3172            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3173            * @return the previous, current, and next blogs entry
3174            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
3175            * @throws SystemException if a system exception occurred
3176            */
3177            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByG_U_LtD_PrevAndNext(
3178                    long entryId, long groupId, long userId, java.util.Date displayDate,
3179                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3180                    throws com.liferay.portal.kernel.exception.SystemException,
3181                            com.liferay.portlet.blogs.NoSuchEntryException {
3182                    return getPersistence()
3183                                       .findByG_U_LtD_PrevAndNext(entryId, groupId, userId,
3184                            displayDate, orderByComparator);
3185            }
3186    
3187            /**
3188            * Returns all the blogs entries that the user has permission to view where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
3189            *
3190            * @param groupId the group ID
3191            * @param userId the user ID
3192            * @param displayDate the display date
3193            * @return the matching blogs entries that the user has permission to view
3194            * @throws SystemException if a system exception occurred
3195            */
3196            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_LtD(
3197                    long groupId, long userId, java.util.Date displayDate)
3198                    throws com.liferay.portal.kernel.exception.SystemException {
3199                    return getPersistence().filterFindByG_U_LtD(groupId, userId, displayDate);
3200            }
3201    
3202            /**
3203            * Returns a range of all the blogs entries that the user has permission to view where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
3204            *
3205            * <p>
3206            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3207            * </p>
3208            *
3209            * @param groupId the group ID
3210            * @param userId the user ID
3211            * @param displayDate the display date
3212            * @param start the lower bound of the range of blogs entries
3213            * @param end the upper bound of the range of blogs entries (not inclusive)
3214            * @return the range of matching blogs entries that the user has permission to view
3215            * @throws SystemException if a system exception occurred
3216            */
3217            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_LtD(
3218                    long groupId, long userId, java.util.Date displayDate, int start,
3219                    int end) throws com.liferay.portal.kernel.exception.SystemException {
3220                    return getPersistence()
3221                                       .filterFindByG_U_LtD(groupId, userId, displayDate, start, end);
3222            }
3223    
3224            /**
3225            * Returns an ordered range of all the blogs entries that the user has permissions to view where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
3226            *
3227            * <p>
3228            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3229            * </p>
3230            *
3231            * @param groupId the group ID
3232            * @param userId the user ID
3233            * @param displayDate the display date
3234            * @param start the lower bound of the range of blogs entries
3235            * @param end the upper bound of the range of blogs entries (not inclusive)
3236            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3237            * @return the ordered range of matching blogs entries that the user has permission to view
3238            * @throws SystemException if a system exception occurred
3239            */
3240            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_LtD(
3241                    long groupId, long userId, java.util.Date displayDate, int start,
3242                    int end,
3243                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3244                    throws com.liferay.portal.kernel.exception.SystemException {
3245                    return getPersistence()
3246                                       .filterFindByG_U_LtD(groupId, userId, displayDate, start,
3247                            end, orderByComparator);
3248            }
3249    
3250            /**
3251            * Returns the blogs entries before and after the current blogs entry in the ordered set of blogs entries that the user has permission to view where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
3252            *
3253            * @param entryId the primary key of the current blogs entry
3254            * @param groupId the group ID
3255            * @param userId the user ID
3256            * @param displayDate the display date
3257            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3258            * @return the previous, current, and next blogs entry
3259            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
3260            * @throws SystemException if a system exception occurred
3261            */
3262            public static com.liferay.portlet.blogs.model.BlogsEntry[] filterFindByG_U_LtD_PrevAndNext(
3263                    long entryId, long groupId, long userId, java.util.Date displayDate,
3264                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3265                    throws com.liferay.portal.kernel.exception.SystemException,
3266                            com.liferay.portlet.blogs.NoSuchEntryException {
3267                    return getPersistence()
3268                                       .filterFindByG_U_LtD_PrevAndNext(entryId, groupId, userId,
3269                            displayDate, orderByComparator);
3270            }
3271    
3272            /**
3273            * Returns all the blogs entries where groupId = &#63; and userId = &#63; and status &ne; &#63;.
3274            *
3275            * @param groupId the group ID
3276            * @param userId the user ID
3277            * @param status the status
3278            * @return the matching blogs entries
3279            * @throws SystemException if a system exception occurred
3280            */
3281            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_NeS(
3282                    long groupId, long userId, int status)
3283                    throws com.liferay.portal.kernel.exception.SystemException {
3284                    return getPersistence().findByG_U_NeS(groupId, userId, status);
3285            }
3286    
3287            /**
3288            * Returns a range of all the blogs entries where groupId = &#63; and userId = &#63; and status &ne; &#63;.
3289            *
3290            * <p>
3291            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3292            * </p>
3293            *
3294            * @param groupId the group ID
3295            * @param userId the user ID
3296            * @param status the status
3297            * @param start the lower bound of the range of blogs entries
3298            * @param end the upper bound of the range of blogs entries (not inclusive)
3299            * @return the range of matching blogs entries
3300            * @throws SystemException if a system exception occurred
3301            */
3302            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_NeS(
3303                    long groupId, long userId, int status, int start, int end)
3304                    throws com.liferay.portal.kernel.exception.SystemException {
3305                    return getPersistence()
3306                                       .findByG_U_NeS(groupId, userId, status, start, end);
3307            }
3308    
3309            /**
3310            * Returns an ordered range of all the blogs entries where groupId = &#63; and userId = &#63; and status &ne; &#63;.
3311            *
3312            * <p>
3313            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3314            * </p>
3315            *
3316            * @param groupId the group ID
3317            * @param userId the user ID
3318            * @param status the status
3319            * @param start the lower bound of the range of blogs entries
3320            * @param end the upper bound of the range of blogs entries (not inclusive)
3321            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3322            * @return the ordered range of matching blogs entries
3323            * @throws SystemException if a system exception occurred
3324            */
3325            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_NeS(
3326                    long groupId, long userId, int status, int start, int end,
3327                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3328                    throws com.liferay.portal.kernel.exception.SystemException {
3329                    return getPersistence()
3330                                       .findByG_U_NeS(groupId, userId, status, start, end,
3331                            orderByComparator);
3332            }
3333    
3334            /**
3335            * Returns the first blogs entry in the ordered set where groupId = &#63; and userId = &#63; and status &ne; &#63;.
3336            *
3337            * @param groupId the group ID
3338            * @param userId the user ID
3339            * @param status the status
3340            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3341            * @return the first matching blogs entry
3342            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
3343            * @throws SystemException if a system exception occurred
3344            */
3345            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_U_NeS_First(
3346                    long groupId, long userId, int status,
3347                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3348                    throws com.liferay.portal.kernel.exception.SystemException,
3349                            com.liferay.portlet.blogs.NoSuchEntryException {
3350                    return getPersistence()
3351                                       .findByG_U_NeS_First(groupId, userId, status,
3352                            orderByComparator);
3353            }
3354    
3355            /**
3356            * Returns the first blogs entry in the ordered set where groupId = &#63; and userId = &#63; and status &ne; &#63;.
3357            *
3358            * @param groupId the group ID
3359            * @param userId the user ID
3360            * @param status the status
3361            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3362            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
3363            * @throws SystemException if a system exception occurred
3364            */
3365            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_U_NeS_First(
3366                    long groupId, long userId, int status,
3367                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3368                    throws com.liferay.portal.kernel.exception.SystemException {
3369                    return getPersistence()
3370                                       .fetchByG_U_NeS_First(groupId, userId, status,
3371                            orderByComparator);
3372            }
3373    
3374            /**
3375            * Returns the last blogs entry in the ordered set where groupId = &#63; and userId = &#63; and status &ne; &#63;.
3376            *
3377            * @param groupId the group ID
3378            * @param userId the user ID
3379            * @param status the status
3380            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3381            * @return the last matching blogs entry
3382            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
3383            * @throws SystemException if a system exception occurred
3384            */
3385            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_U_NeS_Last(
3386                    long groupId, long userId, int status,
3387                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3388                    throws com.liferay.portal.kernel.exception.SystemException,
3389                            com.liferay.portlet.blogs.NoSuchEntryException {
3390                    return getPersistence()
3391                                       .findByG_U_NeS_Last(groupId, userId, status,
3392                            orderByComparator);
3393            }
3394    
3395            /**
3396            * Returns the last blogs entry in the ordered set where groupId = &#63; and userId = &#63; and status &ne; &#63;.
3397            *
3398            * @param groupId the group ID
3399            * @param userId the user ID
3400            * @param status the status
3401            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3402            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
3403            * @throws SystemException if a system exception occurred
3404            */
3405            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_U_NeS_Last(
3406                    long groupId, long userId, int status,
3407                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3408                    throws com.liferay.portal.kernel.exception.SystemException {
3409                    return getPersistence()
3410                                       .fetchByG_U_NeS_Last(groupId, userId, status,
3411                            orderByComparator);
3412            }
3413    
3414            /**
3415            * Returns the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63; and userId = &#63; and status &ne; &#63;.
3416            *
3417            * @param entryId the primary key of the current blogs entry
3418            * @param groupId the group ID
3419            * @param userId the user ID
3420            * @param status the status
3421            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3422            * @return the previous, current, and next blogs entry
3423            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
3424            * @throws SystemException if a system exception occurred
3425            */
3426            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByG_U_NeS_PrevAndNext(
3427                    long entryId, long groupId, long userId, int status,
3428                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3429                    throws com.liferay.portal.kernel.exception.SystemException,
3430                            com.liferay.portlet.blogs.NoSuchEntryException {
3431                    return getPersistence()
3432                                       .findByG_U_NeS_PrevAndNext(entryId, groupId, userId, status,
3433                            orderByComparator);
3434            }
3435    
3436            /**
3437            * Returns all the blogs entries that the user has permission to view where groupId = &#63; and userId = &#63; and status &ne; &#63;.
3438            *
3439            * @param groupId the group ID
3440            * @param userId the user ID
3441            * @param status the status
3442            * @return the matching blogs entries that the user has permission to view
3443            * @throws SystemException if a system exception occurred
3444            */
3445            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_NeS(
3446                    long groupId, long userId, int status)
3447                    throws com.liferay.portal.kernel.exception.SystemException {
3448                    return getPersistence().filterFindByG_U_NeS(groupId, userId, status);
3449            }
3450    
3451            /**
3452            * Returns a range of all the blogs entries that the user has permission to view where groupId = &#63; and userId = &#63; and status &ne; &#63;.
3453            *
3454            * <p>
3455            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3456            * </p>
3457            *
3458            * @param groupId the group ID
3459            * @param userId the user ID
3460            * @param status the status
3461            * @param start the lower bound of the range of blogs entries
3462            * @param end the upper bound of the range of blogs entries (not inclusive)
3463            * @return the range of matching blogs entries that the user has permission to view
3464            * @throws SystemException if a system exception occurred
3465            */
3466            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_NeS(
3467                    long groupId, long userId, int status, int start, int end)
3468                    throws com.liferay.portal.kernel.exception.SystemException {
3469                    return getPersistence()
3470                                       .filterFindByG_U_NeS(groupId, userId, status, start, end);
3471            }
3472    
3473            /**
3474            * Returns an ordered range of all the blogs entries that the user has permissions to view where groupId = &#63; and userId = &#63; and status &ne; &#63;.
3475            *
3476            * <p>
3477            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3478            * </p>
3479            *
3480            * @param groupId the group ID
3481            * @param userId the user ID
3482            * @param status the status
3483            * @param start the lower bound of the range of blogs entries
3484            * @param end the upper bound of the range of blogs entries (not inclusive)
3485            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3486            * @return the ordered range of matching blogs entries that the user has permission to view
3487            * @throws SystemException if a system exception occurred
3488            */
3489            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_NeS(
3490                    long groupId, long userId, int status, int start, int end,
3491                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3492                    throws com.liferay.portal.kernel.exception.SystemException {
3493                    return getPersistence()
3494                                       .filterFindByG_U_NeS(groupId, userId, status, start, end,
3495                            orderByComparator);
3496            }
3497    
3498            /**
3499            * Returns the blogs entries before and after the current blogs entry in the ordered set of blogs entries that the user has permission to view where groupId = &#63; and userId = &#63; and status &ne; &#63;.
3500            *
3501            * @param entryId the primary key of the current blogs entry
3502            * @param groupId the group ID
3503            * @param userId the user ID
3504            * @param status the status
3505            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3506            * @return the previous, current, and next blogs entry
3507            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
3508            * @throws SystemException if a system exception occurred
3509            */
3510            public static com.liferay.portlet.blogs.model.BlogsEntry[] filterFindByG_U_NeS_PrevAndNext(
3511                    long entryId, long groupId, long userId, int status,
3512                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3513                    throws com.liferay.portal.kernel.exception.SystemException,
3514                            com.liferay.portlet.blogs.NoSuchEntryException {
3515                    return getPersistence()
3516                                       .filterFindByG_U_NeS_PrevAndNext(entryId, groupId, userId,
3517                            status, orderByComparator);
3518            }
3519    
3520            /**
3521            * Returns all the blogs entries where groupId = &#63; and userId = &#63; and status = &#63;.
3522            *
3523            * @param groupId the group ID
3524            * @param userId the user ID
3525            * @param status the status
3526            * @return the matching blogs entries
3527            * @throws SystemException if a system exception occurred
3528            */
3529            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_S(
3530                    long groupId, long userId, int status)
3531                    throws com.liferay.portal.kernel.exception.SystemException {
3532                    return getPersistence().findByG_U_S(groupId, userId, status);
3533            }
3534    
3535            /**
3536            * Returns a range of all the blogs entries where groupId = &#63; and userId = &#63; and status = &#63;.
3537            *
3538            * <p>
3539            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3540            * </p>
3541            *
3542            * @param groupId the group ID
3543            * @param userId the user ID
3544            * @param status the status
3545            * @param start the lower bound of the range of blogs entries
3546            * @param end the upper bound of the range of blogs entries (not inclusive)
3547            * @return the range of matching blogs entries
3548            * @throws SystemException if a system exception occurred
3549            */
3550            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_S(
3551                    long groupId, long userId, int status, int start, int end)
3552                    throws com.liferay.portal.kernel.exception.SystemException {
3553                    return getPersistence().findByG_U_S(groupId, userId, status, start, end);
3554            }
3555    
3556            /**
3557            * Returns an ordered range of all the blogs entries where groupId = &#63; and userId = &#63; and status = &#63;.
3558            *
3559            * <p>
3560            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3561            * </p>
3562            *
3563            * @param groupId the group ID
3564            * @param userId the user ID
3565            * @param status the status
3566            * @param start the lower bound of the range of blogs entries
3567            * @param end the upper bound of the range of blogs entries (not inclusive)
3568            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3569            * @return the ordered range of matching blogs entries
3570            * @throws SystemException if a system exception occurred
3571            */
3572            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_S(
3573                    long groupId, long userId, int status, int start, int end,
3574                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3575                    throws com.liferay.portal.kernel.exception.SystemException {
3576                    return getPersistence()
3577                                       .findByG_U_S(groupId, userId, status, start, end,
3578                            orderByComparator);
3579            }
3580    
3581            /**
3582            * Returns the first blogs entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
3583            *
3584            * @param groupId the group ID
3585            * @param userId the user ID
3586            * @param status the status
3587            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3588            * @return the first matching blogs entry
3589            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
3590            * @throws SystemException if a system exception occurred
3591            */
3592            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_U_S_First(
3593                    long groupId, long userId, int status,
3594                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3595                    throws com.liferay.portal.kernel.exception.SystemException,
3596                            com.liferay.portlet.blogs.NoSuchEntryException {
3597                    return getPersistence()
3598                                       .findByG_U_S_First(groupId, userId, status, orderByComparator);
3599            }
3600    
3601            /**
3602            * Returns the first blogs entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
3603            *
3604            * @param groupId the group ID
3605            * @param userId the user ID
3606            * @param status the status
3607            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3608            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
3609            * @throws SystemException if a system exception occurred
3610            */
3611            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_U_S_First(
3612                    long groupId, long userId, int status,
3613                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3614                    throws com.liferay.portal.kernel.exception.SystemException {
3615                    return getPersistence()
3616                                       .fetchByG_U_S_First(groupId, userId, status,
3617                            orderByComparator);
3618            }
3619    
3620            /**
3621            * Returns the last blogs entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
3622            *
3623            * @param groupId the group ID
3624            * @param userId the user ID
3625            * @param status the status
3626            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3627            * @return the last matching blogs entry
3628            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
3629            * @throws SystemException if a system exception occurred
3630            */
3631            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_U_S_Last(
3632                    long groupId, long userId, int status,
3633                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3634                    throws com.liferay.portal.kernel.exception.SystemException,
3635                            com.liferay.portlet.blogs.NoSuchEntryException {
3636                    return getPersistence()
3637                                       .findByG_U_S_Last(groupId, userId, status, orderByComparator);
3638            }
3639    
3640            /**
3641            * Returns the last blogs entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
3642            *
3643            * @param groupId the group ID
3644            * @param userId the user ID
3645            * @param status the status
3646            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3647            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
3648            * @throws SystemException if a system exception occurred
3649            */
3650            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_U_S_Last(
3651                    long groupId, long userId, int status,
3652                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3653                    throws com.liferay.portal.kernel.exception.SystemException {
3654                    return getPersistence()
3655                                       .fetchByG_U_S_Last(groupId, userId, status, orderByComparator);
3656            }
3657    
3658            /**
3659            * Returns the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
3660            *
3661            * @param entryId the primary key of the current blogs entry
3662            * @param groupId the group ID
3663            * @param userId the user ID
3664            * @param status the status
3665            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3666            * @return the previous, current, and next blogs entry
3667            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
3668            * @throws SystemException if a system exception occurred
3669            */
3670            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByG_U_S_PrevAndNext(
3671                    long entryId, long groupId, long userId, int status,
3672                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3673                    throws com.liferay.portal.kernel.exception.SystemException,
3674                            com.liferay.portlet.blogs.NoSuchEntryException {
3675                    return getPersistence()
3676                                       .findByG_U_S_PrevAndNext(entryId, groupId, userId, status,
3677                            orderByComparator);
3678            }
3679    
3680            /**
3681            * Returns all the blogs entries that the user has permission to view where groupId = &#63; and userId = &#63; and status = &#63;.
3682            *
3683            * @param groupId the group ID
3684            * @param userId the user ID
3685            * @param status the status
3686            * @return the matching blogs entries that the user has permission to view
3687            * @throws SystemException if a system exception occurred
3688            */
3689            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_S(
3690                    long groupId, long userId, int status)
3691                    throws com.liferay.portal.kernel.exception.SystemException {
3692                    return getPersistence().filterFindByG_U_S(groupId, userId, status);
3693            }
3694    
3695            /**
3696            * Returns a range of all the blogs entries that the user has permission to view where groupId = &#63; and userId = &#63; and status = &#63;.
3697            *
3698            * <p>
3699            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3700            * </p>
3701            *
3702            * @param groupId the group ID
3703            * @param userId the user ID
3704            * @param status the status
3705            * @param start the lower bound of the range of blogs entries
3706            * @param end the upper bound of the range of blogs entries (not inclusive)
3707            * @return the range of matching blogs entries that the user has permission to view
3708            * @throws SystemException if a system exception occurred
3709            */
3710            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_S(
3711                    long groupId, long userId, int status, int start, int end)
3712                    throws com.liferay.portal.kernel.exception.SystemException {
3713                    return getPersistence()
3714                                       .filterFindByG_U_S(groupId, userId, status, start, end);
3715            }
3716    
3717            /**
3718            * Returns an ordered range of all the blogs entries that the user has permissions to view where groupId = &#63; and userId = &#63; and status = &#63;.
3719            *
3720            * <p>
3721            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3722            * </p>
3723            *
3724            * @param groupId the group ID
3725            * @param userId the user ID
3726            * @param status the status
3727            * @param start the lower bound of the range of blogs entries
3728            * @param end the upper bound of the range of blogs entries (not inclusive)
3729            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3730            * @return the ordered range of matching blogs entries that the user has permission to view
3731            * @throws SystemException if a system exception occurred
3732            */
3733            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_S(
3734                    long groupId, long userId, int status, int start, int end,
3735                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3736                    throws com.liferay.portal.kernel.exception.SystemException {
3737                    return getPersistence()
3738                                       .filterFindByG_U_S(groupId, userId, status, start, end,
3739                            orderByComparator);
3740            }
3741    
3742            /**
3743            * Returns the blogs entries before and after the current blogs entry in the ordered set of blogs entries that the user has permission to view where groupId = &#63; and userId = &#63; and status = &#63;.
3744            *
3745            * @param entryId the primary key of the current blogs entry
3746            * @param groupId the group ID
3747            * @param userId the user ID
3748            * @param status the status
3749            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3750            * @return the previous, current, and next blogs entry
3751            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
3752            * @throws SystemException if a system exception occurred
3753            */
3754            public static com.liferay.portlet.blogs.model.BlogsEntry[] filterFindByG_U_S_PrevAndNext(
3755                    long entryId, long groupId, long userId, int status,
3756                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3757                    throws com.liferay.portal.kernel.exception.SystemException,
3758                            com.liferay.portlet.blogs.NoSuchEntryException {
3759                    return getPersistence()
3760                                       .filterFindByG_U_S_PrevAndNext(entryId, groupId, userId,
3761                            status, orderByComparator);
3762            }
3763    
3764            /**
3765            * Returns all the blogs entries where groupId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
3766            *
3767            * @param groupId the group ID
3768            * @param displayDate the display date
3769            * @param status the status
3770            * @return the matching blogs entries
3771            * @throws SystemException if a system exception occurred
3772            */
3773            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_LtD_NeS(
3774                    long groupId, java.util.Date displayDate, int status)
3775                    throws com.liferay.portal.kernel.exception.SystemException {
3776                    return getPersistence().findByG_LtD_NeS(groupId, displayDate, status);
3777            }
3778    
3779            /**
3780            * Returns a range of all the blogs entries where groupId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
3781            *
3782            * <p>
3783            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3784            * </p>
3785            *
3786            * @param groupId the group ID
3787            * @param displayDate the display date
3788            * @param status the status
3789            * @param start the lower bound of the range of blogs entries
3790            * @param end the upper bound of the range of blogs entries (not inclusive)
3791            * @return the range of matching blogs entries
3792            * @throws SystemException if a system exception occurred
3793            */
3794            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_LtD_NeS(
3795                    long groupId, java.util.Date displayDate, int status, int start, int end)
3796                    throws com.liferay.portal.kernel.exception.SystemException {
3797                    return getPersistence()
3798                                       .findByG_LtD_NeS(groupId, displayDate, status, start, end);
3799            }
3800    
3801            /**
3802            * Returns an ordered range of all the blogs entries where groupId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
3803            *
3804            * <p>
3805            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3806            * </p>
3807            *
3808            * @param groupId the group ID
3809            * @param displayDate the display date
3810            * @param status the status
3811            * @param start the lower bound of the range of blogs entries
3812            * @param end the upper bound of the range of blogs entries (not inclusive)
3813            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3814            * @return the ordered range of matching blogs entries
3815            * @throws SystemException if a system exception occurred
3816            */
3817            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_LtD_NeS(
3818                    long groupId, java.util.Date displayDate, int status, int start,
3819                    int end,
3820                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3821                    throws com.liferay.portal.kernel.exception.SystemException {
3822                    return getPersistence()
3823                                       .findByG_LtD_NeS(groupId, displayDate, status, start, end,
3824                            orderByComparator);
3825            }
3826    
3827            /**
3828            * Returns the first blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
3829            *
3830            * @param groupId the group ID
3831            * @param displayDate the display date
3832            * @param status the status
3833            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3834            * @return the first matching blogs entry
3835            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
3836            * @throws SystemException if a system exception occurred
3837            */
3838            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_LtD_NeS_First(
3839                    long groupId, java.util.Date displayDate, int status,
3840                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3841                    throws com.liferay.portal.kernel.exception.SystemException,
3842                            com.liferay.portlet.blogs.NoSuchEntryException {
3843                    return getPersistence()
3844                                       .findByG_LtD_NeS_First(groupId, displayDate, status,
3845                            orderByComparator);
3846            }
3847    
3848            /**
3849            * Returns the first blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
3850            *
3851            * @param groupId the group ID
3852            * @param displayDate the display date
3853            * @param status the status
3854            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3855            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
3856            * @throws SystemException if a system exception occurred
3857            */
3858            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_LtD_NeS_First(
3859                    long groupId, java.util.Date displayDate, int status,
3860                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3861                    throws com.liferay.portal.kernel.exception.SystemException {
3862                    return getPersistence()
3863                                       .fetchByG_LtD_NeS_First(groupId, displayDate, status,
3864                            orderByComparator);
3865            }
3866    
3867            /**
3868            * Returns the last blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
3869            *
3870            * @param groupId the group ID
3871            * @param displayDate the display date
3872            * @param status the status
3873            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3874            * @return the last matching blogs entry
3875            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
3876            * @throws SystemException if a system exception occurred
3877            */
3878            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_LtD_NeS_Last(
3879                    long groupId, java.util.Date displayDate, int status,
3880                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3881                    throws com.liferay.portal.kernel.exception.SystemException,
3882                            com.liferay.portlet.blogs.NoSuchEntryException {
3883                    return getPersistence()
3884                                       .findByG_LtD_NeS_Last(groupId, displayDate, status,
3885                            orderByComparator);
3886            }
3887    
3888            /**
3889            * Returns the last blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
3890            *
3891            * @param groupId the group ID
3892            * @param displayDate the display date
3893            * @param status the status
3894            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3895            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
3896            * @throws SystemException if a system exception occurred
3897            */
3898            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_LtD_NeS_Last(
3899                    long groupId, java.util.Date displayDate, int status,
3900                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3901                    throws com.liferay.portal.kernel.exception.SystemException {
3902                    return getPersistence()
3903                                       .fetchByG_LtD_NeS_Last(groupId, displayDate, status,
3904                            orderByComparator);
3905            }
3906    
3907            /**
3908            * Returns the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
3909            *
3910            * @param entryId the primary key of the current blogs entry
3911            * @param groupId the group ID
3912            * @param displayDate the display date
3913            * @param status the status
3914            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
3915            * @return the previous, current, and next blogs entry
3916            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
3917            * @throws SystemException if a system exception occurred
3918            */
3919            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByG_LtD_NeS_PrevAndNext(
3920                    long entryId, long groupId, java.util.Date displayDate, int status,
3921                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3922                    throws com.liferay.portal.kernel.exception.SystemException,
3923                            com.liferay.portlet.blogs.NoSuchEntryException {
3924                    return getPersistence()
3925                                       .findByG_LtD_NeS_PrevAndNext(entryId, groupId, displayDate,
3926                            status, orderByComparator);
3927            }
3928    
3929            /**
3930            * Returns all the blogs entries that the user has permission to view where groupId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
3931            *
3932            * @param groupId the group ID
3933            * @param displayDate the display date
3934            * @param status the status
3935            * @return the matching blogs entries that the user has permission to view
3936            * @throws SystemException if a system exception occurred
3937            */
3938            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_LtD_NeS(
3939                    long groupId, java.util.Date displayDate, int status)
3940                    throws com.liferay.portal.kernel.exception.SystemException {
3941                    return getPersistence()
3942                                       .filterFindByG_LtD_NeS(groupId, displayDate, status);
3943            }
3944    
3945            /**
3946            * Returns a range of all the blogs entries that the user has permission to view where groupId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
3947            *
3948            * <p>
3949            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3950            * </p>
3951            *
3952            * @param groupId the group ID
3953            * @param displayDate the display date
3954            * @param status the status
3955            * @param start the lower bound of the range of blogs entries
3956            * @param end the upper bound of the range of blogs entries (not inclusive)
3957            * @return the range of matching blogs entries that the user has permission to view
3958            * @throws SystemException if a system exception occurred
3959            */
3960            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_LtD_NeS(
3961                    long groupId, java.util.Date displayDate, int status, int start, int end)
3962                    throws com.liferay.portal.kernel.exception.SystemException {
3963                    return getPersistence()
3964                                       .filterFindByG_LtD_NeS(groupId, displayDate, status, start,
3965                            end);
3966            }
3967    
3968            /**
3969            * Returns an ordered range of all the blogs entries that the user has permissions to view where groupId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
3970            *
3971            * <p>
3972            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
3973            * </p>
3974            *
3975            * @param groupId the group ID
3976            * @param displayDate the display date
3977            * @param status the status
3978            * @param start the lower bound of the range of blogs entries
3979            * @param end the upper bound of the range of blogs entries (not inclusive)
3980            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
3981            * @return the ordered range of matching blogs entries that the user has permission to view
3982            * @throws SystemException if a system exception occurred
3983            */
3984            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_LtD_NeS(
3985                    long groupId, java.util.Date displayDate, int status, int start,
3986                    int end,
3987                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
3988                    throws com.liferay.portal.kernel.exception.SystemException {
3989                    return getPersistence()
3990                                       .filterFindByG_LtD_NeS(groupId, displayDate, status, start,
3991                            end, orderByComparator);
3992            }
3993    
3994            /**
3995            * Returns the blogs entries before and after the current blogs entry in the ordered set of blogs entries that the user has permission to view where groupId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
3996            *
3997            * @param entryId the primary key of the current blogs entry
3998            * @param groupId the group ID
3999            * @param displayDate the display date
4000            * @param status the status
4001            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4002            * @return the previous, current, and next blogs entry
4003            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
4004            * @throws SystemException if a system exception occurred
4005            */
4006            public static com.liferay.portlet.blogs.model.BlogsEntry[] filterFindByG_LtD_NeS_PrevAndNext(
4007                    long entryId, long groupId, java.util.Date displayDate, int status,
4008                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4009                    throws com.liferay.portal.kernel.exception.SystemException,
4010                            com.liferay.portlet.blogs.NoSuchEntryException {
4011                    return getPersistence()
4012                                       .filterFindByG_LtD_NeS_PrevAndNext(entryId, groupId,
4013                            displayDate, status, orderByComparator);
4014            }
4015    
4016            /**
4017            * Returns all the blogs entries where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
4018            *
4019            * @param groupId the group ID
4020            * @param displayDate the display date
4021            * @param status the status
4022            * @return the matching blogs entries
4023            * @throws SystemException if a system exception occurred
4024            */
4025            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_LtD_S(
4026                    long groupId, java.util.Date displayDate, int status)
4027                    throws com.liferay.portal.kernel.exception.SystemException {
4028                    return getPersistence().findByG_LtD_S(groupId, displayDate, status);
4029            }
4030    
4031            /**
4032            * Returns a range of all the blogs entries where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
4033            *
4034            * <p>
4035            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4036            * </p>
4037            *
4038            * @param groupId the group ID
4039            * @param displayDate the display date
4040            * @param status the status
4041            * @param start the lower bound of the range of blogs entries
4042            * @param end the upper bound of the range of blogs entries (not inclusive)
4043            * @return the range of matching blogs entries
4044            * @throws SystemException if a system exception occurred
4045            */
4046            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_LtD_S(
4047                    long groupId, java.util.Date displayDate, int status, int start, int end)
4048                    throws com.liferay.portal.kernel.exception.SystemException {
4049                    return getPersistence()
4050                                       .findByG_LtD_S(groupId, displayDate, status, start, end);
4051            }
4052    
4053            /**
4054            * Returns an ordered range of all the blogs entries where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
4055            *
4056            * <p>
4057            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4058            * </p>
4059            *
4060            * @param groupId the group ID
4061            * @param displayDate the display date
4062            * @param status the status
4063            * @param start the lower bound of the range of blogs entries
4064            * @param end the upper bound of the range of blogs entries (not inclusive)
4065            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4066            * @return the ordered range of matching blogs entries
4067            * @throws SystemException if a system exception occurred
4068            */
4069            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_LtD_S(
4070                    long groupId, java.util.Date displayDate, int status, int start,
4071                    int end,
4072                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4073                    throws com.liferay.portal.kernel.exception.SystemException {
4074                    return getPersistence()
4075                                       .findByG_LtD_S(groupId, displayDate, status, start, end,
4076                            orderByComparator);
4077            }
4078    
4079            /**
4080            * Returns the first blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
4081            *
4082            * @param groupId the group ID
4083            * @param displayDate the display date
4084            * @param status the status
4085            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4086            * @return the first matching blogs entry
4087            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
4088            * @throws SystemException if a system exception occurred
4089            */
4090            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_LtD_S_First(
4091                    long groupId, java.util.Date displayDate, int status,
4092                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4093                    throws com.liferay.portal.kernel.exception.SystemException,
4094                            com.liferay.portlet.blogs.NoSuchEntryException {
4095                    return getPersistence()
4096                                       .findByG_LtD_S_First(groupId, displayDate, status,
4097                            orderByComparator);
4098            }
4099    
4100            /**
4101            * Returns the first blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
4102            *
4103            * @param groupId the group ID
4104            * @param displayDate the display date
4105            * @param status the status
4106            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4107            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
4108            * @throws SystemException if a system exception occurred
4109            */
4110            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_LtD_S_First(
4111                    long groupId, java.util.Date displayDate, int status,
4112                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4113                    throws com.liferay.portal.kernel.exception.SystemException {
4114                    return getPersistence()
4115                                       .fetchByG_LtD_S_First(groupId, displayDate, status,
4116                            orderByComparator);
4117            }
4118    
4119            /**
4120            * Returns the last blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
4121            *
4122            * @param groupId the group ID
4123            * @param displayDate the display date
4124            * @param status the status
4125            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4126            * @return the last matching blogs entry
4127            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
4128            * @throws SystemException if a system exception occurred
4129            */
4130            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_LtD_S_Last(
4131                    long groupId, java.util.Date displayDate, int status,
4132                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4133                    throws com.liferay.portal.kernel.exception.SystemException,
4134                            com.liferay.portlet.blogs.NoSuchEntryException {
4135                    return getPersistence()
4136                                       .findByG_LtD_S_Last(groupId, displayDate, status,
4137                            orderByComparator);
4138            }
4139    
4140            /**
4141            * Returns the last blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
4142            *
4143            * @param groupId the group ID
4144            * @param displayDate the display date
4145            * @param status the status
4146            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4147            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
4148            * @throws SystemException if a system exception occurred
4149            */
4150            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_LtD_S_Last(
4151                    long groupId, java.util.Date displayDate, int status,
4152                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4153                    throws com.liferay.portal.kernel.exception.SystemException {
4154                    return getPersistence()
4155                                       .fetchByG_LtD_S_Last(groupId, displayDate, status,
4156                            orderByComparator);
4157            }
4158    
4159            /**
4160            * Returns the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
4161            *
4162            * @param entryId the primary key of the current blogs entry
4163            * @param groupId the group ID
4164            * @param displayDate the display date
4165            * @param status the status
4166            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4167            * @return the previous, current, and next blogs entry
4168            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
4169            * @throws SystemException if a system exception occurred
4170            */
4171            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByG_LtD_S_PrevAndNext(
4172                    long entryId, long groupId, java.util.Date displayDate, int status,
4173                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4174                    throws com.liferay.portal.kernel.exception.SystemException,
4175                            com.liferay.portlet.blogs.NoSuchEntryException {
4176                    return getPersistence()
4177                                       .findByG_LtD_S_PrevAndNext(entryId, groupId, displayDate,
4178                            status, orderByComparator);
4179            }
4180    
4181            /**
4182            * Returns all the blogs entries that the user has permission to view where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
4183            *
4184            * @param groupId the group ID
4185            * @param displayDate the display date
4186            * @param status the status
4187            * @return the matching blogs entries that the user has permission to view
4188            * @throws SystemException if a system exception occurred
4189            */
4190            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_LtD_S(
4191                    long groupId, java.util.Date displayDate, int status)
4192                    throws com.liferay.portal.kernel.exception.SystemException {
4193                    return getPersistence().filterFindByG_LtD_S(groupId, displayDate, status);
4194            }
4195    
4196            /**
4197            * Returns a range of all the blogs entries that the user has permission to view where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
4198            *
4199            * <p>
4200            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4201            * </p>
4202            *
4203            * @param groupId the group ID
4204            * @param displayDate the display date
4205            * @param status the status
4206            * @param start the lower bound of the range of blogs entries
4207            * @param end the upper bound of the range of blogs entries (not inclusive)
4208            * @return the range of matching blogs entries that the user has permission to view
4209            * @throws SystemException if a system exception occurred
4210            */
4211            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_LtD_S(
4212                    long groupId, java.util.Date displayDate, int status, int start, int end)
4213                    throws com.liferay.portal.kernel.exception.SystemException {
4214                    return getPersistence()
4215                                       .filterFindByG_LtD_S(groupId, displayDate, status, start, end);
4216            }
4217    
4218            /**
4219            * Returns an ordered range of all the blogs entries that the user has permissions to view where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
4220            *
4221            * <p>
4222            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4223            * </p>
4224            *
4225            * @param groupId the group ID
4226            * @param displayDate the display date
4227            * @param status the status
4228            * @param start the lower bound of the range of blogs entries
4229            * @param end the upper bound of the range of blogs entries (not inclusive)
4230            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4231            * @return the ordered range of matching blogs entries that the user has permission to view
4232            * @throws SystemException if a system exception occurred
4233            */
4234            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_LtD_S(
4235                    long groupId, java.util.Date displayDate, int status, int start,
4236                    int end,
4237                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4238                    throws com.liferay.portal.kernel.exception.SystemException {
4239                    return getPersistence()
4240                                       .filterFindByG_LtD_S(groupId, displayDate, status, start,
4241                            end, orderByComparator);
4242            }
4243    
4244            /**
4245            * Returns the blogs entries before and after the current blogs entry in the ordered set of blogs entries that the user has permission to view where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
4246            *
4247            * @param entryId the primary key of the current blogs entry
4248            * @param groupId the group ID
4249            * @param displayDate the display date
4250            * @param status the status
4251            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4252            * @return the previous, current, and next blogs entry
4253            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
4254            * @throws SystemException if a system exception occurred
4255            */
4256            public static com.liferay.portlet.blogs.model.BlogsEntry[] filterFindByG_LtD_S_PrevAndNext(
4257                    long entryId, long groupId, java.util.Date displayDate, int status,
4258                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4259                    throws com.liferay.portal.kernel.exception.SystemException,
4260                            com.liferay.portlet.blogs.NoSuchEntryException {
4261                    return getPersistence()
4262                                       .filterFindByG_LtD_S_PrevAndNext(entryId, groupId,
4263                            displayDate, status, orderByComparator);
4264            }
4265    
4266            /**
4267            * Returns all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
4268            *
4269            * @param groupId the group ID
4270            * @param userId the user ID
4271            * @param displayDate the display date
4272            * @param status the status
4273            * @return the matching blogs entries
4274            * @throws SystemException if a system exception occurred
4275            */
4276            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_LtD_NeS(
4277                    long groupId, long userId, java.util.Date displayDate, int status)
4278                    throws com.liferay.portal.kernel.exception.SystemException {
4279                    return getPersistence()
4280                                       .findByG_U_LtD_NeS(groupId, userId, displayDate, status);
4281            }
4282    
4283            /**
4284            * Returns a range of all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
4285            *
4286            * <p>
4287            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4288            * </p>
4289            *
4290            * @param groupId the group ID
4291            * @param userId the user ID
4292            * @param displayDate the display date
4293            * @param status the status
4294            * @param start the lower bound of the range of blogs entries
4295            * @param end the upper bound of the range of blogs entries (not inclusive)
4296            * @return the range of matching blogs entries
4297            * @throws SystemException if a system exception occurred
4298            */
4299            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_LtD_NeS(
4300                    long groupId, long userId, java.util.Date displayDate, int status,
4301                    int start, int end)
4302                    throws com.liferay.portal.kernel.exception.SystemException {
4303                    return getPersistence()
4304                                       .findByG_U_LtD_NeS(groupId, userId, displayDate, status,
4305                            start, end);
4306            }
4307    
4308            /**
4309            * Returns an ordered range of all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
4310            *
4311            * <p>
4312            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4313            * </p>
4314            *
4315            * @param groupId the group ID
4316            * @param userId the user ID
4317            * @param displayDate the display date
4318            * @param status the status
4319            * @param start the lower bound of the range of blogs entries
4320            * @param end the upper bound of the range of blogs entries (not inclusive)
4321            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4322            * @return the ordered range of matching blogs entries
4323            * @throws SystemException if a system exception occurred
4324            */
4325            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_LtD_NeS(
4326                    long groupId, long userId, java.util.Date displayDate, int status,
4327                    int start, int end,
4328                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4329                    throws com.liferay.portal.kernel.exception.SystemException {
4330                    return getPersistence()
4331                                       .findByG_U_LtD_NeS(groupId, userId, displayDate, status,
4332                            start, end, orderByComparator);
4333            }
4334    
4335            /**
4336            * Returns the first blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
4337            *
4338            * @param groupId the group ID
4339            * @param userId the user ID
4340            * @param displayDate the display date
4341            * @param status the status
4342            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4343            * @return the first matching blogs entry
4344            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
4345            * @throws SystemException if a system exception occurred
4346            */
4347            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_U_LtD_NeS_First(
4348                    long groupId, long userId, java.util.Date displayDate, int status,
4349                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4350                    throws com.liferay.portal.kernel.exception.SystemException,
4351                            com.liferay.portlet.blogs.NoSuchEntryException {
4352                    return getPersistence()
4353                                       .findByG_U_LtD_NeS_First(groupId, userId, displayDate,
4354                            status, orderByComparator);
4355            }
4356    
4357            /**
4358            * Returns the first blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
4359            *
4360            * @param groupId the group ID
4361            * @param userId the user ID
4362            * @param displayDate the display date
4363            * @param status the status
4364            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4365            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
4366            * @throws SystemException if a system exception occurred
4367            */
4368            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_U_LtD_NeS_First(
4369                    long groupId, long userId, java.util.Date displayDate, int status,
4370                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4371                    throws com.liferay.portal.kernel.exception.SystemException {
4372                    return getPersistence()
4373                                       .fetchByG_U_LtD_NeS_First(groupId, userId, displayDate,
4374                            status, orderByComparator);
4375            }
4376    
4377            /**
4378            * Returns the last blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
4379            *
4380            * @param groupId the group ID
4381            * @param userId the user ID
4382            * @param displayDate the display date
4383            * @param status the status
4384            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4385            * @return the last matching blogs entry
4386            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
4387            * @throws SystemException if a system exception occurred
4388            */
4389            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_U_LtD_NeS_Last(
4390                    long groupId, long userId, java.util.Date displayDate, int status,
4391                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4392                    throws com.liferay.portal.kernel.exception.SystemException,
4393                            com.liferay.portlet.blogs.NoSuchEntryException {
4394                    return getPersistence()
4395                                       .findByG_U_LtD_NeS_Last(groupId, userId, displayDate,
4396                            status, orderByComparator);
4397            }
4398    
4399            /**
4400            * Returns the last blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
4401            *
4402            * @param groupId the group ID
4403            * @param userId the user ID
4404            * @param displayDate the display date
4405            * @param status the status
4406            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4407            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
4408            * @throws SystemException if a system exception occurred
4409            */
4410            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_U_LtD_NeS_Last(
4411                    long groupId, long userId, java.util.Date displayDate, int status,
4412                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4413                    throws com.liferay.portal.kernel.exception.SystemException {
4414                    return getPersistence()
4415                                       .fetchByG_U_LtD_NeS_Last(groupId, userId, displayDate,
4416                            status, orderByComparator);
4417            }
4418    
4419            /**
4420            * Returns the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
4421            *
4422            * @param entryId the primary key of the current blogs entry
4423            * @param groupId the group ID
4424            * @param userId the user ID
4425            * @param displayDate the display date
4426            * @param status the status
4427            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4428            * @return the previous, current, and next blogs entry
4429            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
4430            * @throws SystemException if a system exception occurred
4431            */
4432            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByG_U_LtD_NeS_PrevAndNext(
4433                    long entryId, long groupId, long userId, java.util.Date displayDate,
4434                    int status,
4435                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4436                    throws com.liferay.portal.kernel.exception.SystemException,
4437                            com.liferay.portlet.blogs.NoSuchEntryException {
4438                    return getPersistence()
4439                                       .findByG_U_LtD_NeS_PrevAndNext(entryId, groupId, userId,
4440                            displayDate, status, orderByComparator);
4441            }
4442    
4443            /**
4444            * Returns all the blogs entries that the user has permission to view where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
4445            *
4446            * @param groupId the group ID
4447            * @param userId the user ID
4448            * @param displayDate the display date
4449            * @param status the status
4450            * @return the matching blogs entries that the user has permission to view
4451            * @throws SystemException if a system exception occurred
4452            */
4453            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_LtD_NeS(
4454                    long groupId, long userId, java.util.Date displayDate, int status)
4455                    throws com.liferay.portal.kernel.exception.SystemException {
4456                    return getPersistence()
4457                                       .filterFindByG_U_LtD_NeS(groupId, userId, displayDate, status);
4458            }
4459    
4460            /**
4461            * Returns a range of all the blogs entries that the user has permission to view where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
4462            *
4463            * <p>
4464            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4465            * </p>
4466            *
4467            * @param groupId the group ID
4468            * @param userId the user ID
4469            * @param displayDate the display date
4470            * @param status the status
4471            * @param start the lower bound of the range of blogs entries
4472            * @param end the upper bound of the range of blogs entries (not inclusive)
4473            * @return the range of matching blogs entries that the user has permission to view
4474            * @throws SystemException if a system exception occurred
4475            */
4476            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_LtD_NeS(
4477                    long groupId, long userId, java.util.Date displayDate, int status,
4478                    int start, int end)
4479                    throws com.liferay.portal.kernel.exception.SystemException {
4480                    return getPersistence()
4481                                       .filterFindByG_U_LtD_NeS(groupId, userId, displayDate,
4482                            status, start, end);
4483            }
4484    
4485            /**
4486            * Returns an ordered range of all the blogs entries that the user has permissions to view where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
4487            *
4488            * <p>
4489            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4490            * </p>
4491            *
4492            * @param groupId the group ID
4493            * @param userId the user ID
4494            * @param displayDate the display date
4495            * @param status the status
4496            * @param start the lower bound of the range of blogs entries
4497            * @param end the upper bound of the range of blogs entries (not inclusive)
4498            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4499            * @return the ordered range of matching blogs entries that the user has permission to view
4500            * @throws SystemException if a system exception occurred
4501            */
4502            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_LtD_NeS(
4503                    long groupId, long userId, java.util.Date displayDate, int status,
4504                    int start, int end,
4505                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4506                    throws com.liferay.portal.kernel.exception.SystemException {
4507                    return getPersistence()
4508                                       .filterFindByG_U_LtD_NeS(groupId, userId, displayDate,
4509                            status, start, end, orderByComparator);
4510            }
4511    
4512            /**
4513            * Returns the blogs entries before and after the current blogs entry in the ordered set of blogs entries that the user has permission to view where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
4514            *
4515            * @param entryId the primary key of the current blogs entry
4516            * @param groupId the group ID
4517            * @param userId the user ID
4518            * @param displayDate the display date
4519            * @param status the status
4520            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4521            * @return the previous, current, and next blogs entry
4522            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
4523            * @throws SystemException if a system exception occurred
4524            */
4525            public static com.liferay.portlet.blogs.model.BlogsEntry[] filterFindByG_U_LtD_NeS_PrevAndNext(
4526                    long entryId, long groupId, long userId, java.util.Date displayDate,
4527                    int status,
4528                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4529                    throws com.liferay.portal.kernel.exception.SystemException,
4530                            com.liferay.portlet.blogs.NoSuchEntryException {
4531                    return getPersistence()
4532                                       .filterFindByG_U_LtD_NeS_PrevAndNext(entryId, groupId,
4533                            userId, displayDate, status, orderByComparator);
4534            }
4535    
4536            /**
4537            * Returns all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
4538            *
4539            * @param groupId the group ID
4540            * @param userId the user ID
4541            * @param displayDate the display date
4542            * @param status the status
4543            * @return the matching blogs entries
4544            * @throws SystemException if a system exception occurred
4545            */
4546            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_LtD_S(
4547                    long groupId, long userId, java.util.Date displayDate, int status)
4548                    throws com.liferay.portal.kernel.exception.SystemException {
4549                    return getPersistence()
4550                                       .findByG_U_LtD_S(groupId, userId, displayDate, status);
4551            }
4552    
4553            /**
4554            * Returns a range of all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
4555            *
4556            * <p>
4557            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4558            * </p>
4559            *
4560            * @param groupId the group ID
4561            * @param userId the user ID
4562            * @param displayDate the display date
4563            * @param status the status
4564            * @param start the lower bound of the range of blogs entries
4565            * @param end the upper bound of the range of blogs entries (not inclusive)
4566            * @return the range of matching blogs entries
4567            * @throws SystemException if a system exception occurred
4568            */
4569            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_LtD_S(
4570                    long groupId, long userId, java.util.Date displayDate, int status,
4571                    int start, int end)
4572                    throws com.liferay.portal.kernel.exception.SystemException {
4573                    return getPersistence()
4574                                       .findByG_U_LtD_S(groupId, userId, displayDate, status,
4575                            start, end);
4576            }
4577    
4578            /**
4579            * Returns an ordered range of all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
4580            *
4581            * <p>
4582            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4583            * </p>
4584            *
4585            * @param groupId the group ID
4586            * @param userId the user ID
4587            * @param displayDate the display date
4588            * @param status the status
4589            * @param start the lower bound of the range of blogs entries
4590            * @param end the upper bound of the range of blogs entries (not inclusive)
4591            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4592            * @return the ordered range of matching blogs entries
4593            * @throws SystemException if a system exception occurred
4594            */
4595            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_LtD_S(
4596                    long groupId, long userId, java.util.Date displayDate, int status,
4597                    int start, int end,
4598                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4599                    throws com.liferay.portal.kernel.exception.SystemException {
4600                    return getPersistence()
4601                                       .findByG_U_LtD_S(groupId, userId, displayDate, status,
4602                            start, end, orderByComparator);
4603            }
4604    
4605            /**
4606            * Returns the first blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
4607            *
4608            * @param groupId the group ID
4609            * @param userId the user ID
4610            * @param displayDate the display date
4611            * @param status the status
4612            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4613            * @return the first matching blogs entry
4614            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
4615            * @throws SystemException if a system exception occurred
4616            */
4617            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_U_LtD_S_First(
4618                    long groupId, long userId, java.util.Date displayDate, int status,
4619                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4620                    throws com.liferay.portal.kernel.exception.SystemException,
4621                            com.liferay.portlet.blogs.NoSuchEntryException {
4622                    return getPersistence()
4623                                       .findByG_U_LtD_S_First(groupId, userId, displayDate, status,
4624                            orderByComparator);
4625            }
4626    
4627            /**
4628            * Returns the first blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
4629            *
4630            * @param groupId the group ID
4631            * @param userId the user ID
4632            * @param displayDate the display date
4633            * @param status the status
4634            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4635            * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
4636            * @throws SystemException if a system exception occurred
4637            */
4638            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_U_LtD_S_First(
4639                    long groupId, long userId, java.util.Date displayDate, int status,
4640                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4641                    throws com.liferay.portal.kernel.exception.SystemException {
4642                    return getPersistence()
4643                                       .fetchByG_U_LtD_S_First(groupId, userId, displayDate,
4644                            status, orderByComparator);
4645            }
4646    
4647            /**
4648            * Returns the last blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
4649            *
4650            * @param groupId the group ID
4651            * @param userId the user ID
4652            * @param displayDate the display date
4653            * @param status the status
4654            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4655            * @return the last matching blogs entry
4656            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
4657            * @throws SystemException if a system exception occurred
4658            */
4659            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_U_LtD_S_Last(
4660                    long groupId, long userId, java.util.Date displayDate, int status,
4661                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4662                    throws com.liferay.portal.kernel.exception.SystemException,
4663                            com.liferay.portlet.blogs.NoSuchEntryException {
4664                    return getPersistence()
4665                                       .findByG_U_LtD_S_Last(groupId, userId, displayDate, status,
4666                            orderByComparator);
4667            }
4668    
4669            /**
4670            * Returns the last blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
4671            *
4672            * @param groupId the group ID
4673            * @param userId the user ID
4674            * @param displayDate the display date
4675            * @param status the status
4676            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4677            * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
4678            * @throws SystemException if a system exception occurred
4679            */
4680            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_U_LtD_S_Last(
4681                    long groupId, long userId, java.util.Date displayDate, int status,
4682                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4683                    throws com.liferay.portal.kernel.exception.SystemException {
4684                    return getPersistence()
4685                                       .fetchByG_U_LtD_S_Last(groupId, userId, displayDate, status,
4686                            orderByComparator);
4687            }
4688    
4689            /**
4690            * Returns the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
4691            *
4692            * @param entryId the primary key of the current blogs entry
4693            * @param groupId the group ID
4694            * @param userId the user ID
4695            * @param displayDate the display date
4696            * @param status the status
4697            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4698            * @return the previous, current, and next blogs entry
4699            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
4700            * @throws SystemException if a system exception occurred
4701            */
4702            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByG_U_LtD_S_PrevAndNext(
4703                    long entryId, long groupId, long userId, java.util.Date displayDate,
4704                    int status,
4705                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4706                    throws com.liferay.portal.kernel.exception.SystemException,
4707                            com.liferay.portlet.blogs.NoSuchEntryException {
4708                    return getPersistence()
4709                                       .findByG_U_LtD_S_PrevAndNext(entryId, groupId, userId,
4710                            displayDate, status, orderByComparator);
4711            }
4712    
4713            /**
4714            * Returns all the blogs entries that the user has permission to view where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
4715            *
4716            * @param groupId the group ID
4717            * @param userId the user ID
4718            * @param displayDate the display date
4719            * @param status the status
4720            * @return the matching blogs entries that the user has permission to view
4721            * @throws SystemException if a system exception occurred
4722            */
4723            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_LtD_S(
4724                    long groupId, long userId, java.util.Date displayDate, int status)
4725                    throws com.liferay.portal.kernel.exception.SystemException {
4726                    return getPersistence()
4727                                       .filterFindByG_U_LtD_S(groupId, userId, displayDate, status);
4728            }
4729    
4730            /**
4731            * Returns a range of all the blogs entries that the user has permission to view where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
4732            *
4733            * <p>
4734            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4735            * </p>
4736            *
4737            * @param groupId the group ID
4738            * @param userId the user ID
4739            * @param displayDate the display date
4740            * @param status the status
4741            * @param start the lower bound of the range of blogs entries
4742            * @param end the upper bound of the range of blogs entries (not inclusive)
4743            * @return the range of matching blogs entries that the user has permission to view
4744            * @throws SystemException if a system exception occurred
4745            */
4746            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_LtD_S(
4747                    long groupId, long userId, java.util.Date displayDate, int status,
4748                    int start, int end)
4749                    throws com.liferay.portal.kernel.exception.SystemException {
4750                    return getPersistence()
4751                                       .filterFindByG_U_LtD_S(groupId, userId, displayDate, status,
4752                            start, end);
4753            }
4754    
4755            /**
4756            * Returns an ordered range of all the blogs entries that the user has permissions to view where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
4757            *
4758            * <p>
4759            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4760            * </p>
4761            *
4762            * @param groupId the group ID
4763            * @param userId the user ID
4764            * @param displayDate the display date
4765            * @param status the status
4766            * @param start the lower bound of the range of blogs entries
4767            * @param end the upper bound of the range of blogs entries (not inclusive)
4768            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4769            * @return the ordered range of matching blogs entries that the user has permission to view
4770            * @throws SystemException if a system exception occurred
4771            */
4772            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_LtD_S(
4773                    long groupId, long userId, java.util.Date displayDate, int status,
4774                    int start, int end,
4775                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4776                    throws com.liferay.portal.kernel.exception.SystemException {
4777                    return getPersistence()
4778                                       .filterFindByG_U_LtD_S(groupId, userId, displayDate, status,
4779                            start, end, orderByComparator);
4780            }
4781    
4782            /**
4783            * Returns the blogs entries before and after the current blogs entry in the ordered set of blogs entries that the user has permission to view where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
4784            *
4785            * @param entryId the primary key of the current blogs entry
4786            * @param groupId the group ID
4787            * @param userId the user ID
4788            * @param displayDate the display date
4789            * @param status the status
4790            * @param orderByComparator the comparator to order the set by (optionally <code>null</code>)
4791            * @return the previous, current, and next blogs entry
4792            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
4793            * @throws SystemException if a system exception occurred
4794            */
4795            public static com.liferay.portlet.blogs.model.BlogsEntry[] filterFindByG_U_LtD_S_PrevAndNext(
4796                    long entryId, long groupId, long userId, java.util.Date displayDate,
4797                    int status,
4798                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4799                    throws com.liferay.portal.kernel.exception.SystemException,
4800                            com.liferay.portlet.blogs.NoSuchEntryException {
4801                    return getPersistence()
4802                                       .filterFindByG_U_LtD_S_PrevAndNext(entryId, groupId, userId,
4803                            displayDate, status, orderByComparator);
4804            }
4805    
4806            /**
4807            * Returns all the blogs entries.
4808            *
4809            * @return the blogs entries
4810            * @throws SystemException if a system exception occurred
4811            */
4812            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findAll()
4813                    throws com.liferay.portal.kernel.exception.SystemException {
4814                    return getPersistence().findAll();
4815            }
4816    
4817            /**
4818            * Returns a range of all the blogs entries.
4819            *
4820            * <p>
4821            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4822            * </p>
4823            *
4824            * @param start the lower bound of the range of blogs entries
4825            * @param end the upper bound of the range of blogs entries (not inclusive)
4826            * @return the range of blogs entries
4827            * @throws SystemException if a system exception occurred
4828            */
4829            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findAll(
4830                    int start, int end)
4831                    throws com.liferay.portal.kernel.exception.SystemException {
4832                    return getPersistence().findAll(start, end);
4833            }
4834    
4835            /**
4836            * Returns an ordered range of all the blogs entries.
4837            *
4838            * <p>
4839            * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set.
4840            * </p>
4841            *
4842            * @param start the lower bound of the range of blogs entries
4843            * @param end the upper bound of the range of blogs entries (not inclusive)
4844            * @param orderByComparator the comparator to order the results by (optionally <code>null</code>)
4845            * @return the ordered range of blogs entries
4846            * @throws SystemException if a system exception occurred
4847            */
4848            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findAll(
4849                    int start, int end,
4850                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
4851                    throws com.liferay.portal.kernel.exception.SystemException {
4852                    return getPersistence().findAll(start, end, orderByComparator);
4853            }
4854    
4855            /**
4856            * Removes all the blogs entries where uuid = &#63; from the database.
4857            *
4858            * @param uuid the uuid
4859            * @throws SystemException if a system exception occurred
4860            */
4861            public static void removeByUuid(java.lang.String uuid)
4862                    throws com.liferay.portal.kernel.exception.SystemException {
4863                    getPersistence().removeByUuid(uuid);
4864            }
4865    
4866            /**
4867            * Removes the blogs entry where uuid = &#63; and groupId = &#63; from the database.
4868            *
4869            * @param uuid the uuid
4870            * @param groupId the group ID
4871            * @return the blogs entry that was removed
4872            * @throws SystemException if a system exception occurred
4873            */
4874            public static com.liferay.portlet.blogs.model.BlogsEntry removeByUUID_G(
4875                    java.lang.String uuid, long groupId)
4876                    throws com.liferay.portal.kernel.exception.SystemException,
4877                            com.liferay.portlet.blogs.NoSuchEntryException {
4878                    return getPersistence().removeByUUID_G(uuid, groupId);
4879            }
4880    
4881            /**
4882            * Removes all the blogs entries where uuid = &#63; and companyId = &#63; from the database.
4883            *
4884            * @param uuid the uuid
4885            * @param companyId the company ID
4886            * @throws SystemException if a system exception occurred
4887            */
4888            public static void removeByUuid_C(java.lang.String uuid, long companyId)
4889                    throws com.liferay.portal.kernel.exception.SystemException {
4890                    getPersistence().removeByUuid_C(uuid, companyId);
4891            }
4892    
4893            /**
4894            * Removes all the blogs entries where groupId = &#63; from the database.
4895            *
4896            * @param groupId the group ID
4897            * @throws SystemException if a system exception occurred
4898            */
4899            public static void removeByGroupId(long groupId)
4900                    throws com.liferay.portal.kernel.exception.SystemException {
4901                    getPersistence().removeByGroupId(groupId);
4902            }
4903    
4904            /**
4905            * Removes all the blogs entries where companyId = &#63; from the database.
4906            *
4907            * @param companyId the company ID
4908            * @throws SystemException if a system exception occurred
4909            */
4910            public static void removeByCompanyId(long companyId)
4911                    throws com.liferay.portal.kernel.exception.SystemException {
4912                    getPersistence().removeByCompanyId(companyId);
4913            }
4914    
4915            /**
4916            * Removes all the blogs entries where companyId = &#63; and userId = &#63; from the database.
4917            *
4918            * @param companyId the company ID
4919            * @param userId the user ID
4920            * @throws SystemException if a system exception occurred
4921            */
4922            public static void removeByC_U(long companyId, long userId)
4923                    throws com.liferay.portal.kernel.exception.SystemException {
4924                    getPersistence().removeByC_U(companyId, userId);
4925            }
4926    
4927            /**
4928            * Removes all the blogs entries where companyId = &#63; and displayDate &lt; &#63; from the database.
4929            *
4930            * @param companyId the company ID
4931            * @param displayDate the display date
4932            * @throws SystemException if a system exception occurred
4933            */
4934            public static void removeByC_LtD(long companyId, java.util.Date displayDate)
4935                    throws com.liferay.portal.kernel.exception.SystemException {
4936                    getPersistence().removeByC_LtD(companyId, displayDate);
4937            }
4938    
4939            /**
4940            * Removes all the blogs entries where companyId = &#63; and status &ne; &#63; from the database.
4941            *
4942            * @param companyId the company ID
4943            * @param status the status
4944            * @throws SystemException if a system exception occurred
4945            */
4946            public static void removeByC_NeS(long companyId, int status)
4947                    throws com.liferay.portal.kernel.exception.SystemException {
4948                    getPersistence().removeByC_NeS(companyId, status);
4949            }
4950    
4951            /**
4952            * Removes all the blogs entries where companyId = &#63; and status = &#63; from the database.
4953            *
4954            * @param companyId the company ID
4955            * @param status the status
4956            * @throws SystemException if a system exception occurred
4957            */
4958            public static void removeByC_S(long companyId, int status)
4959                    throws com.liferay.portal.kernel.exception.SystemException {
4960                    getPersistence().removeByC_S(companyId, status);
4961            }
4962    
4963            /**
4964            * Removes the blogs entry where groupId = &#63; and urlTitle = &#63; from the database.
4965            *
4966            * @param groupId the group ID
4967            * @param urlTitle the url title
4968            * @return the blogs entry that was removed
4969            * @throws SystemException if a system exception occurred
4970            */
4971            public static com.liferay.portlet.blogs.model.BlogsEntry removeByG_UT(
4972                    long groupId, java.lang.String urlTitle)
4973                    throws com.liferay.portal.kernel.exception.SystemException,
4974                            com.liferay.portlet.blogs.NoSuchEntryException {
4975                    return getPersistence().removeByG_UT(groupId, urlTitle);
4976            }
4977    
4978            /**
4979            * Removes all the blogs entries where groupId = &#63; and displayDate &lt; &#63; from the database.
4980            *
4981            * @param groupId the group ID
4982            * @param displayDate the display date
4983            * @throws SystemException if a system exception occurred
4984            */
4985            public static void removeByG_LtD(long groupId, java.util.Date displayDate)
4986                    throws com.liferay.portal.kernel.exception.SystemException {
4987                    getPersistence().removeByG_LtD(groupId, displayDate);
4988            }
4989    
4990            /**
4991            * Removes all the blogs entries where groupId = &#63; and status &ne; &#63; from the database.
4992            *
4993            * @param groupId the group ID
4994            * @param status the status
4995            * @throws SystemException if a system exception occurred
4996            */
4997            public static void removeByG_NeS(long groupId, int status)
4998                    throws com.liferay.portal.kernel.exception.SystemException {
4999                    getPersistence().removeByG_NeS(groupId, status);
5000            }
5001    
5002            /**
5003            * Removes all the blogs entries where groupId = &#63; and status = &#63; from the database.
5004            *
5005            * @param groupId the group ID
5006            * @param status the status
5007            * @throws SystemException if a system exception occurred
5008            */
5009            public static void removeByG_S(long groupId, int status)
5010                    throws com.liferay.portal.kernel.exception.SystemException {
5011                    getPersistence().removeByG_S(groupId, status);
5012            }
5013    
5014            /**
5015            * Removes all the blogs entries where displayDate &lt; &#63; and status = &#63; from the database.
5016            *
5017            * @param displayDate the display date
5018            * @param status the status
5019            * @throws SystemException if a system exception occurred
5020            */
5021            public static void removeByLtD_S(java.util.Date displayDate, int status)
5022                    throws com.liferay.portal.kernel.exception.SystemException {
5023                    getPersistence().removeByLtD_S(displayDate, status);
5024            }
5025    
5026            /**
5027            * Removes all the blogs entries where companyId = &#63; and userId = &#63; and status &ne; &#63; from the database.
5028            *
5029            * @param companyId the company ID
5030            * @param userId the user ID
5031            * @param status the status
5032            * @throws SystemException if a system exception occurred
5033            */
5034            public static void removeByC_U_NeS(long companyId, long userId, int status)
5035                    throws com.liferay.portal.kernel.exception.SystemException {
5036                    getPersistence().removeByC_U_NeS(companyId, userId, status);
5037            }
5038    
5039            /**
5040            * Removes all the blogs entries where companyId = &#63; and userId = &#63; and status = &#63; from the database.
5041            *
5042            * @param companyId the company ID
5043            * @param userId the user ID
5044            * @param status the status
5045            * @throws SystemException if a system exception occurred
5046            */
5047            public static void removeByC_U_S(long companyId, long userId, int status)
5048                    throws com.liferay.portal.kernel.exception.SystemException {
5049                    getPersistence().removeByC_U_S(companyId, userId, status);
5050            }
5051    
5052            /**
5053            * Removes all the blogs entries where companyId = &#63; and displayDate &lt; &#63; and status &ne; &#63; from the database.
5054            *
5055            * @param companyId the company ID
5056            * @param displayDate the display date
5057            * @param status the status
5058            * @throws SystemException if a system exception occurred
5059            */
5060            public static void removeByC_LtD_NeS(long companyId,
5061                    java.util.Date displayDate, int status)
5062                    throws com.liferay.portal.kernel.exception.SystemException {
5063                    getPersistence().removeByC_LtD_NeS(companyId, displayDate, status);
5064            }
5065    
5066            /**
5067            * Removes all the blogs entries where companyId = &#63; and displayDate &lt; &#63; and status = &#63; from the database.
5068            *
5069            * @param companyId the company ID
5070            * @param displayDate the display date
5071            * @param status the status
5072            * @throws SystemException if a system exception occurred
5073            */
5074            public static void removeByC_LtD_S(long companyId,
5075                    java.util.Date displayDate, int status)
5076                    throws com.liferay.portal.kernel.exception.SystemException {
5077                    getPersistence().removeByC_LtD_S(companyId, displayDate, status);
5078            }
5079    
5080            /**
5081            * Removes all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; from the database.
5082            *
5083            * @param groupId the group ID
5084            * @param userId the user ID
5085            * @param displayDate the display date
5086            * @throws SystemException if a system exception occurred
5087            */
5088            public static void removeByG_U_LtD(long groupId, long userId,
5089                    java.util.Date displayDate)
5090                    throws com.liferay.portal.kernel.exception.SystemException {
5091                    getPersistence().removeByG_U_LtD(groupId, userId, displayDate);
5092            }
5093    
5094            /**
5095            * Removes all the blogs entries where groupId = &#63; and userId = &#63; and status &ne; &#63; from the database.
5096            *
5097            * @param groupId the group ID
5098            * @param userId the user ID
5099            * @param status the status
5100            * @throws SystemException if a system exception occurred
5101            */
5102            public static void removeByG_U_NeS(long groupId, long userId, int status)
5103                    throws com.liferay.portal.kernel.exception.SystemException {
5104                    getPersistence().removeByG_U_NeS(groupId, userId, status);
5105            }
5106    
5107            /**
5108            * Removes all the blogs entries where groupId = &#63; and userId = &#63; and status = &#63; from the database.
5109            *
5110            * @param groupId the group ID
5111            * @param userId the user ID
5112            * @param status the status
5113            * @throws SystemException if a system exception occurred
5114            */
5115            public static void removeByG_U_S(long groupId, long userId, int status)
5116                    throws com.liferay.portal.kernel.exception.SystemException {
5117                    getPersistence().removeByG_U_S(groupId, userId, status);
5118            }
5119    
5120            /**
5121            * Removes all the blogs entries where groupId = &#63; and displayDate &lt; &#63; and status &ne; &#63; from the database.
5122            *
5123            * @param groupId the group ID
5124            * @param displayDate the display date
5125            * @param status the status
5126            * @throws SystemException if a system exception occurred
5127            */
5128            public static void removeByG_LtD_NeS(long groupId,
5129                    java.util.Date displayDate, int status)
5130                    throws com.liferay.portal.kernel.exception.SystemException {
5131                    getPersistence().removeByG_LtD_NeS(groupId, displayDate, status);
5132            }
5133    
5134            /**
5135            * Removes all the blogs entries where groupId = &#63; and displayDate &lt; &#63; and status = &#63; from the database.
5136            *
5137            * @param groupId the group ID
5138            * @param displayDate the display date
5139            * @param status the status
5140            * @throws SystemException if a system exception occurred
5141            */
5142            public static void removeByG_LtD_S(long groupId,
5143                    java.util.Date displayDate, int status)
5144                    throws com.liferay.portal.kernel.exception.SystemException {
5145                    getPersistence().removeByG_LtD_S(groupId, displayDate, status);
5146            }
5147    
5148            /**
5149            * Removes all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status &ne; &#63; from the database.
5150            *
5151            * @param groupId the group ID
5152            * @param userId the user ID
5153            * @param displayDate the display date
5154            * @param status the status
5155            * @throws SystemException if a system exception occurred
5156            */
5157            public static void removeByG_U_LtD_NeS(long groupId, long userId,
5158                    java.util.Date displayDate, int status)
5159                    throws com.liferay.portal.kernel.exception.SystemException {
5160                    getPersistence()
5161                            .removeByG_U_LtD_NeS(groupId, userId, displayDate, status);
5162            }
5163    
5164            /**
5165            * Removes all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63; from the database.
5166            *
5167            * @param groupId the group ID
5168            * @param userId the user ID
5169            * @param displayDate the display date
5170            * @param status the status
5171            * @throws SystemException if a system exception occurred
5172            */
5173            public static void removeByG_U_LtD_S(long groupId, long userId,
5174                    java.util.Date displayDate, int status)
5175                    throws com.liferay.portal.kernel.exception.SystemException {
5176                    getPersistence().removeByG_U_LtD_S(groupId, userId, displayDate, status);
5177            }
5178    
5179            /**
5180            * Removes all the blogs entries from the database.
5181            *
5182            * @throws SystemException if a system exception occurred
5183            */
5184            public static void removeAll()
5185                    throws com.liferay.portal.kernel.exception.SystemException {
5186                    getPersistence().removeAll();
5187            }
5188    
5189            /**
5190            * Returns the number of blogs entries where uuid = &#63;.
5191            *
5192            * @param uuid the uuid
5193            * @return the number of matching blogs entries
5194            * @throws SystemException if a system exception occurred
5195            */
5196            public static int countByUuid(java.lang.String uuid)
5197                    throws com.liferay.portal.kernel.exception.SystemException {
5198                    return getPersistence().countByUuid(uuid);
5199            }
5200    
5201            /**
5202            * Returns the number of blogs entries where uuid = &#63; and groupId = &#63;.
5203            *
5204            * @param uuid the uuid
5205            * @param groupId the group ID
5206            * @return the number of matching blogs entries
5207            * @throws SystemException if a system exception occurred
5208            */
5209            public static int countByUUID_G(java.lang.String uuid, long groupId)
5210                    throws com.liferay.portal.kernel.exception.SystemException {
5211                    return getPersistence().countByUUID_G(uuid, groupId);
5212            }
5213    
5214            /**
5215            * Returns the number of blogs entries where uuid = &#63; and companyId = &#63;.
5216            *
5217            * @param uuid the uuid
5218            * @param companyId the company ID
5219            * @return the number of matching blogs entries
5220            * @throws SystemException if a system exception occurred
5221            */
5222            public static int countByUuid_C(java.lang.String uuid, long companyId)
5223                    throws com.liferay.portal.kernel.exception.SystemException {
5224                    return getPersistence().countByUuid_C(uuid, companyId);
5225            }
5226    
5227            /**
5228            * Returns the number of blogs entries where groupId = &#63;.
5229            *
5230            * @param groupId the group ID
5231            * @return the number of matching blogs entries
5232            * @throws SystemException if a system exception occurred
5233            */
5234            public static int countByGroupId(long groupId)
5235                    throws com.liferay.portal.kernel.exception.SystemException {
5236                    return getPersistence().countByGroupId(groupId);
5237            }
5238    
5239            /**
5240            * Returns the number of blogs entries that the user has permission to view where groupId = &#63;.
5241            *
5242            * @param groupId the group ID
5243            * @return the number of matching blogs entries that the user has permission to view
5244            * @throws SystemException if a system exception occurred
5245            */
5246            public static int filterCountByGroupId(long groupId)
5247                    throws com.liferay.portal.kernel.exception.SystemException {
5248                    return getPersistence().filterCountByGroupId(groupId);
5249            }
5250    
5251            /**
5252            * Returns the number of blogs entries where companyId = &#63;.
5253            *
5254            * @param companyId the company ID
5255            * @return the number of matching blogs entries
5256            * @throws SystemException if a system exception occurred
5257            */
5258            public static int countByCompanyId(long companyId)
5259                    throws com.liferay.portal.kernel.exception.SystemException {
5260                    return getPersistence().countByCompanyId(companyId);
5261            }
5262    
5263            /**
5264            * Returns the number of blogs entries where companyId = &#63; and userId = &#63;.
5265            *
5266            * @param companyId the company ID
5267            * @param userId the user ID
5268            * @return the number of matching blogs entries
5269            * @throws SystemException if a system exception occurred
5270            */
5271            public static int countByC_U(long companyId, long userId)
5272                    throws com.liferay.portal.kernel.exception.SystemException {
5273                    return getPersistence().countByC_U(companyId, userId);
5274            }
5275    
5276            /**
5277            * Returns the number of blogs entries where companyId = &#63; and displayDate &lt; &#63;.
5278            *
5279            * @param companyId the company ID
5280            * @param displayDate the display date
5281            * @return the number of matching blogs entries
5282            * @throws SystemException if a system exception occurred
5283            */
5284            public static int countByC_LtD(long companyId, java.util.Date displayDate)
5285                    throws com.liferay.portal.kernel.exception.SystemException {
5286                    return getPersistence().countByC_LtD(companyId, displayDate);
5287            }
5288    
5289            /**
5290            * Returns the number of blogs entries where companyId = &#63; and status &ne; &#63;.
5291            *
5292            * @param companyId the company ID
5293            * @param status the status
5294            * @return the number of matching blogs entries
5295            * @throws SystemException if a system exception occurred
5296            */
5297            public static int countByC_NeS(long companyId, int status)
5298                    throws com.liferay.portal.kernel.exception.SystemException {
5299                    return getPersistence().countByC_NeS(companyId, status);
5300            }
5301    
5302            /**
5303            * Returns the number of blogs entries where companyId = &#63; and status = &#63;.
5304            *
5305            * @param companyId the company ID
5306            * @param status the status
5307            * @return the number of matching blogs entries
5308            * @throws SystemException if a system exception occurred
5309            */
5310            public static int countByC_S(long companyId, int status)
5311                    throws com.liferay.portal.kernel.exception.SystemException {
5312                    return getPersistence().countByC_S(companyId, status);
5313            }
5314    
5315            /**
5316            * Returns the number of blogs entries where groupId = &#63; and urlTitle = &#63;.
5317            *
5318            * @param groupId the group ID
5319            * @param urlTitle the url title
5320            * @return the number of matching blogs entries
5321            * @throws SystemException if a system exception occurred
5322            */
5323            public static int countByG_UT(long groupId, java.lang.String urlTitle)
5324                    throws com.liferay.portal.kernel.exception.SystemException {
5325                    return getPersistence().countByG_UT(groupId, urlTitle);
5326            }
5327    
5328            /**
5329            * Returns the number of blogs entries where groupId = &#63; and displayDate &lt; &#63;.
5330            *
5331            * @param groupId the group ID
5332            * @param displayDate the display date
5333            * @return the number of matching blogs entries
5334            * @throws SystemException if a system exception occurred
5335            */
5336            public static int countByG_LtD(long groupId, java.util.Date displayDate)
5337                    throws com.liferay.portal.kernel.exception.SystemException {
5338                    return getPersistence().countByG_LtD(groupId, displayDate);
5339            }
5340    
5341            /**
5342            * Returns the number of blogs entries that the user has permission to view where groupId = &#63; and displayDate &lt; &#63;.
5343            *
5344            * @param groupId the group ID
5345            * @param displayDate the display date
5346            * @return the number of matching blogs entries that the user has permission to view
5347            * @throws SystemException if a system exception occurred
5348            */
5349            public static int filterCountByG_LtD(long groupId,
5350                    java.util.Date displayDate)
5351                    throws com.liferay.portal.kernel.exception.SystemException {
5352                    return getPersistence().filterCountByG_LtD(groupId, displayDate);
5353            }
5354    
5355            /**
5356            * Returns the number of blogs entries where groupId = &#63; and status &ne; &#63;.
5357            *
5358            * @param groupId the group ID
5359            * @param status the status
5360            * @return the number of matching blogs entries
5361            * @throws SystemException if a system exception occurred
5362            */
5363            public static int countByG_NeS(long groupId, int status)
5364                    throws com.liferay.portal.kernel.exception.SystemException {
5365                    return getPersistence().countByG_NeS(groupId, status);
5366            }
5367    
5368            /**
5369            * Returns the number of blogs entries that the user has permission to view where groupId = &#63; and status &ne; &#63;.
5370            *
5371            * @param groupId the group ID
5372            * @param status the status
5373            * @return the number of matching blogs entries that the user has permission to view
5374            * @throws SystemException if a system exception occurred
5375            */
5376            public static int filterCountByG_NeS(long groupId, int status)
5377                    throws com.liferay.portal.kernel.exception.SystemException {
5378                    return getPersistence().filterCountByG_NeS(groupId, status);
5379            }
5380    
5381            /**
5382            * Returns the number of blogs entries where groupId = &#63; and status = &#63;.
5383            *
5384            * @param groupId the group ID
5385            * @param status the status
5386            * @return the number of matching blogs entries
5387            * @throws SystemException if a system exception occurred
5388            */
5389            public static int countByG_S(long groupId, int status)
5390                    throws com.liferay.portal.kernel.exception.SystemException {
5391                    return getPersistence().countByG_S(groupId, status);
5392            }
5393    
5394            /**
5395            * Returns the number of blogs entries that the user has permission to view where groupId = &#63; and status = &#63;.
5396            *
5397            * @param groupId the group ID
5398            * @param status the status
5399            * @return the number of matching blogs entries that the user has permission to view
5400            * @throws SystemException if a system exception occurred
5401            */
5402            public static int filterCountByG_S(long groupId, int status)
5403                    throws com.liferay.portal.kernel.exception.SystemException {
5404                    return getPersistence().filterCountByG_S(groupId, status);
5405            }
5406    
5407            /**
5408            * Returns the number of blogs entries where displayDate &lt; &#63; and status = &#63;.
5409            *
5410            * @param displayDate the display date
5411            * @param status the status
5412            * @return the number of matching blogs entries
5413            * @throws SystemException if a system exception occurred
5414            */
5415            public static int countByLtD_S(java.util.Date displayDate, int status)
5416                    throws com.liferay.portal.kernel.exception.SystemException {
5417                    return getPersistence().countByLtD_S(displayDate, status);
5418            }
5419    
5420            /**
5421            * Returns the number of blogs entries where companyId = &#63; and userId = &#63; and status &ne; &#63;.
5422            *
5423            * @param companyId the company ID
5424            * @param userId the user ID
5425            * @param status the status
5426            * @return the number of matching blogs entries
5427            * @throws SystemException if a system exception occurred
5428            */
5429            public static int countByC_U_NeS(long companyId, long userId, int status)
5430                    throws com.liferay.portal.kernel.exception.SystemException {
5431                    return getPersistence().countByC_U_NeS(companyId, userId, status);
5432            }
5433    
5434            /**
5435            * Returns the number of blogs entries where companyId = &#63; and userId = &#63; and status = &#63;.
5436            *
5437            * @param companyId the company ID
5438            * @param userId the user ID
5439            * @param status the status
5440            * @return the number of matching blogs entries
5441            * @throws SystemException if a system exception occurred
5442            */
5443            public static int countByC_U_S(long companyId, long userId, int status)
5444                    throws com.liferay.portal.kernel.exception.SystemException {
5445                    return getPersistence().countByC_U_S(companyId, userId, status);
5446            }
5447    
5448            /**
5449            * Returns the number of blogs entries where companyId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
5450            *
5451            * @param companyId the company ID
5452            * @param displayDate the display date
5453            * @param status the status
5454            * @return the number of matching blogs entries
5455            * @throws SystemException if a system exception occurred
5456            */
5457            public static int countByC_LtD_NeS(long companyId,
5458                    java.util.Date displayDate, int status)
5459                    throws com.liferay.portal.kernel.exception.SystemException {
5460                    return getPersistence().countByC_LtD_NeS(companyId, displayDate, status);
5461            }
5462    
5463            /**
5464            * Returns the number of blogs entries where companyId = &#63; and displayDate &lt; &#63; and status = &#63;.
5465            *
5466            * @param companyId the company ID
5467            * @param displayDate the display date
5468            * @param status the status
5469            * @return the number of matching blogs entries
5470            * @throws SystemException if a system exception occurred
5471            */
5472            public static int countByC_LtD_S(long companyId,
5473                    java.util.Date displayDate, int status)
5474                    throws com.liferay.portal.kernel.exception.SystemException {
5475                    return getPersistence().countByC_LtD_S(companyId, displayDate, status);
5476            }
5477    
5478            /**
5479            * Returns the number of blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
5480            *
5481            * @param groupId the group ID
5482            * @param userId the user ID
5483            * @param displayDate the display date
5484            * @return the number of matching blogs entries
5485            * @throws SystemException if a system exception occurred
5486            */
5487            public static int countByG_U_LtD(long groupId, long userId,
5488                    java.util.Date displayDate)
5489                    throws com.liferay.portal.kernel.exception.SystemException {
5490                    return getPersistence().countByG_U_LtD(groupId, userId, displayDate);
5491            }
5492    
5493            /**
5494            * Returns the number of blogs entries that the user has permission to view where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
5495            *
5496            * @param groupId the group ID
5497            * @param userId the user ID
5498            * @param displayDate the display date
5499            * @return the number of matching blogs entries that the user has permission to view
5500            * @throws SystemException if a system exception occurred
5501            */
5502            public static int filterCountByG_U_LtD(long groupId, long userId,
5503                    java.util.Date displayDate)
5504                    throws com.liferay.portal.kernel.exception.SystemException {
5505                    return getPersistence()
5506                                       .filterCountByG_U_LtD(groupId, userId, displayDate);
5507            }
5508    
5509            /**
5510            * Returns the number of blogs entries where groupId = &#63; and userId = &#63; and status &ne; &#63;.
5511            *
5512            * @param groupId the group ID
5513            * @param userId the user ID
5514            * @param status the status
5515            * @return the number of matching blogs entries
5516            * @throws SystemException if a system exception occurred
5517            */
5518            public static int countByG_U_NeS(long groupId, long userId, int status)
5519                    throws com.liferay.portal.kernel.exception.SystemException {
5520                    return getPersistence().countByG_U_NeS(groupId, userId, status);
5521            }
5522    
5523            /**
5524            * Returns the number of blogs entries that the user has permission to view where groupId = &#63; and userId = &#63; and status &ne; &#63;.
5525            *
5526            * @param groupId the group ID
5527            * @param userId the user ID
5528            * @param status the status
5529            * @return the number of matching blogs entries that the user has permission to view
5530            * @throws SystemException if a system exception occurred
5531            */
5532            public static int filterCountByG_U_NeS(long groupId, long userId, int status)
5533                    throws com.liferay.portal.kernel.exception.SystemException {
5534                    return getPersistence().filterCountByG_U_NeS(groupId, userId, status);
5535            }
5536    
5537            /**
5538            * Returns the number of blogs entries where groupId = &#63; and userId = &#63; and status = &#63;.
5539            *
5540            * @param groupId the group ID
5541            * @param userId the user ID
5542            * @param status the status
5543            * @return the number of matching blogs entries
5544            * @throws SystemException if a system exception occurred
5545            */
5546            public static int countByG_U_S(long groupId, long userId, int status)
5547                    throws com.liferay.portal.kernel.exception.SystemException {
5548                    return getPersistence().countByG_U_S(groupId, userId, status);
5549            }
5550    
5551            /**
5552            * Returns the number of blogs entries that the user has permission to view where groupId = &#63; and userId = &#63; and status = &#63;.
5553            *
5554            * @param groupId the group ID
5555            * @param userId the user ID
5556            * @param status the status
5557            * @return the number of matching blogs entries that the user has permission to view
5558            * @throws SystemException if a system exception occurred
5559            */
5560            public static int filterCountByG_U_S(long groupId, long userId, int status)
5561                    throws com.liferay.portal.kernel.exception.SystemException {
5562                    return getPersistence().filterCountByG_U_S(groupId, userId, status);
5563            }
5564    
5565            /**
5566            * Returns the number of blogs entries where groupId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
5567            *
5568            * @param groupId the group ID
5569            * @param displayDate the display date
5570            * @param status the status
5571            * @return the number of matching blogs entries
5572            * @throws SystemException if a system exception occurred
5573            */
5574            public static int countByG_LtD_NeS(long groupId,
5575                    java.util.Date displayDate, int status)
5576                    throws com.liferay.portal.kernel.exception.SystemException {
5577                    return getPersistence().countByG_LtD_NeS(groupId, displayDate, status);
5578            }
5579    
5580            /**
5581            * Returns the number of blogs entries that the user has permission to view where groupId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
5582            *
5583            * @param groupId the group ID
5584            * @param displayDate the display date
5585            * @param status the status
5586            * @return the number of matching blogs entries that the user has permission to view
5587            * @throws SystemException if a system exception occurred
5588            */
5589            public static int filterCountByG_LtD_NeS(long groupId,
5590                    java.util.Date displayDate, int status)
5591                    throws com.liferay.portal.kernel.exception.SystemException {
5592                    return getPersistence()
5593                                       .filterCountByG_LtD_NeS(groupId, displayDate, status);
5594            }
5595    
5596            /**
5597            * Returns the number of blogs entries where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
5598            *
5599            * @param groupId the group ID
5600            * @param displayDate the display date
5601            * @param status the status
5602            * @return the number of matching blogs entries
5603            * @throws SystemException if a system exception occurred
5604            */
5605            public static int countByG_LtD_S(long groupId, java.util.Date displayDate,
5606                    int status) throws com.liferay.portal.kernel.exception.SystemException {
5607                    return getPersistence().countByG_LtD_S(groupId, displayDate, status);
5608            }
5609    
5610            /**
5611            * Returns the number of blogs entries that the user has permission to view where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
5612            *
5613            * @param groupId the group ID
5614            * @param displayDate the display date
5615            * @param status the status
5616            * @return the number of matching blogs entries that the user has permission to view
5617            * @throws SystemException if a system exception occurred
5618            */
5619            public static int filterCountByG_LtD_S(long groupId,
5620                    java.util.Date displayDate, int status)
5621                    throws com.liferay.portal.kernel.exception.SystemException {
5622                    return getPersistence()
5623                                       .filterCountByG_LtD_S(groupId, displayDate, status);
5624            }
5625    
5626            /**
5627            * Returns the number of blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
5628            *
5629            * @param groupId the group ID
5630            * @param userId the user ID
5631            * @param displayDate the display date
5632            * @param status the status
5633            * @return the number of matching blogs entries
5634            * @throws SystemException if a system exception occurred
5635            */
5636            public static int countByG_U_LtD_NeS(long groupId, long userId,
5637                    java.util.Date displayDate, int status)
5638                    throws com.liferay.portal.kernel.exception.SystemException {
5639                    return getPersistence()
5640                                       .countByG_U_LtD_NeS(groupId, userId, displayDate, status);
5641            }
5642    
5643            /**
5644            * Returns the number of blogs entries that the user has permission to view where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status &ne; &#63;.
5645            *
5646            * @param groupId the group ID
5647            * @param userId the user ID
5648            * @param displayDate the display date
5649            * @param status the status
5650            * @return the number of matching blogs entries that the user has permission to view
5651            * @throws SystemException if a system exception occurred
5652            */
5653            public static int filterCountByG_U_LtD_NeS(long groupId, long userId,
5654                    java.util.Date displayDate, int status)
5655                    throws com.liferay.portal.kernel.exception.SystemException {
5656                    return getPersistence()
5657                                       .filterCountByG_U_LtD_NeS(groupId, userId, displayDate,
5658                            status);
5659            }
5660    
5661            /**
5662            * Returns the number of blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
5663            *
5664            * @param groupId the group ID
5665            * @param userId the user ID
5666            * @param displayDate the display date
5667            * @param status the status
5668            * @return the number of matching blogs entries
5669            * @throws SystemException if a system exception occurred
5670            */
5671            public static int countByG_U_LtD_S(long groupId, long userId,
5672                    java.util.Date displayDate, int status)
5673                    throws com.liferay.portal.kernel.exception.SystemException {
5674                    return getPersistence()
5675                                       .countByG_U_LtD_S(groupId, userId, displayDate, status);
5676            }
5677    
5678            /**
5679            * Returns the number of blogs entries that the user has permission to view where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
5680            *
5681            * @param groupId the group ID
5682            * @param userId the user ID
5683            * @param displayDate the display date
5684            * @param status the status
5685            * @return the number of matching blogs entries that the user has permission to view
5686            * @throws SystemException if a system exception occurred
5687            */
5688            public static int filterCountByG_U_LtD_S(long groupId, long userId,
5689                    java.util.Date displayDate, int status)
5690                    throws com.liferay.portal.kernel.exception.SystemException {
5691                    return getPersistence()
5692                                       .filterCountByG_U_LtD_S(groupId, userId, displayDate, status);
5693            }
5694    
5695            /**
5696            * Returns the number of blogs entries.
5697            *
5698            * @return the number of blogs entries
5699            * @throws SystemException if a system exception occurred
5700            */
5701            public static int countAll()
5702                    throws com.liferay.portal.kernel.exception.SystemException {
5703                    return getPersistence().countAll();
5704            }
5705    
5706            public static BlogsEntryPersistence getPersistence() {
5707                    if (_persistence == null) {
5708                            _persistence = (BlogsEntryPersistence)PortalBeanLocatorUtil.locate(BlogsEntryPersistence.class.getName());
5709    
5710                            ReferenceRegistry.registerReference(BlogsEntryUtil.class,
5711                                    "_persistence");
5712                    }
5713    
5714                    return _persistence;
5715            }
5716    
5717            /**
5718             * @deprecated
5719             */
5720            public void setPersistence(BlogsEntryPersistence persistence) {
5721            }
5722    
5723            private static BlogsEntryPersistence _persistence;
5724    }