001    /**
002     * Copyright (c) 2000-2010 Liferay, Inc. All rights reserved.
003     *
004     * This library is free software; you can redistribute it and/or modify it under
005     * the terms of the GNU Lesser General Public License as published by the Free
006     * Software Foundation; either version 2.1 of the License, or (at your option)
007     * any later version.
008     *
009     * This library is distributed in the hope that it will be useful, but WITHOUT
010     * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
011     * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more
012     * details.
013     */
014    
015    package com.liferay.portlet.blogs.service.persistence;
016    
017    import com.liferay.portal.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.service.ServiceContext;
022    
023    import com.liferay.portlet.blogs.model.BlogsEntry;
024    
025    import java.util.List;
026    
027    /**
028     * The persistence utility for the blogs entry service.
029     *
030     * <p>
031     * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regnerate this class.
032     * </p>
033     *
034     * @author Brian Wing Shun Chan
035     * @see BlogsEntryPersistence
036     * @see BlogsEntryPersistenceImpl
037     * @generated
038     */
039    public class BlogsEntryUtil {
040            /**
041             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache()
042             */
043            public static void clearCache() {
044                    getPersistence().clearCache();
045            }
046    
047            /**
048             * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel)
049             */
050            public static void clearCache(BlogsEntry blogsEntry) {
051                    getPersistence().clearCache(blogsEntry);
052            }
053    
054            /**
055             * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery)
056             */
057            public long countWithDynamicQuery(DynamicQuery dynamicQuery)
058                    throws SystemException {
059                    return getPersistence().countWithDynamicQuery(dynamicQuery);
060            }
061    
062            /**
063             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery)
064             */
065            public static List<BlogsEntry> findWithDynamicQuery(
066                    DynamicQuery dynamicQuery) throws SystemException {
067                    return getPersistence().findWithDynamicQuery(dynamicQuery);
068            }
069    
070            /**
071             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int)
072             */
073            public static List<BlogsEntry> findWithDynamicQuery(
074                    DynamicQuery dynamicQuery, int start, int end)
075                    throws SystemException {
076                    return getPersistence().findWithDynamicQuery(dynamicQuery, start, end);
077            }
078    
079            /**
080             * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)
081             */
082            public static List<BlogsEntry> findWithDynamicQuery(
083                    DynamicQuery dynamicQuery, int start, int end,
084                    OrderByComparator orderByComparator) throws SystemException {
085                    return getPersistence()
086                                       .findWithDynamicQuery(dynamicQuery, start, end,
087                            orderByComparator);
088            }
089    
090            /**
091             * @see com.liferay.portal.service.persistence.BasePersistence#remove(com.liferay.portal.model.BaseModel)
092             */
093            public static BlogsEntry remove(BlogsEntry blogsEntry)
094                    throws SystemException {
095                    return getPersistence().remove(blogsEntry);
096            }
097    
098            /**
099             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean)
100             */
101            public static BlogsEntry update(BlogsEntry blogsEntry, boolean merge)
102                    throws SystemException {
103                    return getPersistence().update(blogsEntry, merge);
104            }
105    
106            /**
107             * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext)
108             */
109            public static BlogsEntry update(BlogsEntry blogsEntry, boolean merge,
110                    ServiceContext serviceContext) throws SystemException {
111                    return getPersistence().update(blogsEntry, merge, serviceContext);
112            }
113    
114            /**
115            * Caches the blogs entry in the entity cache if it is enabled.
116            *
117            * @param blogsEntry the blogs entry to cache
118            */
119            public static void cacheResult(
120                    com.liferay.portlet.blogs.model.BlogsEntry blogsEntry) {
121                    getPersistence().cacheResult(blogsEntry);
122            }
123    
124            /**
125            * Caches the blogs entries in the entity cache if it is enabled.
126            *
127            * @param blogsEntries the blogs entries to cache
128            */
129            public static void cacheResult(
130                    java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> blogsEntries) {
131                    getPersistence().cacheResult(blogsEntries);
132            }
133    
134            /**
135            * Creates a new blogs entry with the primary key.
136            *
137            * @param entryId the primary key for the new blogs entry
138            * @return the new blogs entry
139            */
140            public static com.liferay.portlet.blogs.model.BlogsEntry create(
141                    long entryId) {
142                    return getPersistence().create(entryId);
143            }
144    
145            /**
146            * Removes the blogs entry with the primary key from the database. Also notifies the appropriate model listeners.
147            *
148            * @param entryId the primary key of the blogs entry to remove
149            * @return the blogs entry that was removed
150            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
151            * @throws SystemException if a system exception occurred
152            */
153            public static com.liferay.portlet.blogs.model.BlogsEntry remove(
154                    long entryId)
155                    throws com.liferay.portal.kernel.exception.SystemException,
156                            com.liferay.portlet.blogs.NoSuchEntryException {
157                    return getPersistence().remove(entryId);
158            }
159    
160            public static com.liferay.portlet.blogs.model.BlogsEntry updateImpl(
161                    com.liferay.portlet.blogs.model.BlogsEntry blogsEntry, boolean merge)
162                    throws com.liferay.portal.kernel.exception.SystemException {
163                    return getPersistence().updateImpl(blogsEntry, merge);
164            }
165    
166            /**
167            * Finds the blogs entry with the primary key or throws a {@link com.liferay.portlet.blogs.NoSuchEntryException} if it could not be found.
168            *
169            * @param entryId the primary key of the blogs entry to find
170            * @return the blogs entry
171            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
172            * @throws SystemException if a system exception occurred
173            */
174            public static com.liferay.portlet.blogs.model.BlogsEntry findByPrimaryKey(
175                    long entryId)
176                    throws com.liferay.portal.kernel.exception.SystemException,
177                            com.liferay.portlet.blogs.NoSuchEntryException {
178                    return getPersistence().findByPrimaryKey(entryId);
179            }
180    
181            /**
182            * Finds the blogs entry with the primary key or returns <code>null</code> if it could not be found.
183            *
184            * @param entryId the primary key of the blogs entry to find
185            * @return the blogs entry, or <code>null</code> if a blogs entry with the primary key could not be found
186            * @throws SystemException if a system exception occurred
187            */
188            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByPrimaryKey(
189                    long entryId)
190                    throws com.liferay.portal.kernel.exception.SystemException {
191                    return getPersistence().fetchByPrimaryKey(entryId);
192            }
193    
194            /**
195            * Finds all the blogs entries where uuid = &#63;.
196            *
197            * @param uuid the uuid to search with
198            * @return the matching blogs entries
199            * @throws SystemException if a system exception occurred
200            */
201            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByUuid(
202                    java.lang.String uuid)
203                    throws com.liferay.portal.kernel.exception.SystemException {
204                    return getPersistence().findByUuid(uuid);
205            }
206    
207            /**
208            * Finds a range of all the blogs entries where uuid = &#63;.
209            *
210            * <p>
211            * 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.
212            * </p>
213            *
214            * @param uuid the uuid to search with
215            * @param start the lower bound of the range of blogs entries to return
216            * @param end the upper bound of the range of blogs entries to return (not inclusive)
217            * @return the range of matching blogs entries
218            * @throws SystemException if a system exception occurred
219            */
220            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByUuid(
221                    java.lang.String uuid, int start, int end)
222                    throws com.liferay.portal.kernel.exception.SystemException {
223                    return getPersistence().findByUuid(uuid, start, end);
224            }
225    
226            /**
227            * Finds an ordered range of all the blogs entries where uuid = &#63;.
228            *
229            * <p>
230            * 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.
231            * </p>
232            *
233            * @param uuid the uuid to search with
234            * @param start the lower bound of the range of blogs entries to return
235            * @param end the upper bound of the range of blogs entries to return (not inclusive)
236            * @param orderByComparator the comparator to order the results by
237            * @return the ordered range of matching blogs entries
238            * @throws SystemException if a system exception occurred
239            */
240            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByUuid(
241                    java.lang.String uuid, int start, int end,
242                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
243                    throws com.liferay.portal.kernel.exception.SystemException {
244                    return getPersistence().findByUuid(uuid, start, end, orderByComparator);
245            }
246    
247            /**
248            * Finds the first blogs entry in the ordered set where uuid = &#63;.
249            *
250            * <p>
251            * 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.
252            * </p>
253            *
254            * @param uuid the uuid to search with
255            * @param orderByComparator the comparator to order the set by
256            * @return the first matching blogs entry
257            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
258            * @throws SystemException if a system exception occurred
259            */
260            public static com.liferay.portlet.blogs.model.BlogsEntry findByUuid_First(
261                    java.lang.String uuid,
262                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
263                    throws com.liferay.portal.kernel.exception.SystemException,
264                            com.liferay.portlet.blogs.NoSuchEntryException {
265                    return getPersistence().findByUuid_First(uuid, orderByComparator);
266            }
267    
268            /**
269            * Finds the last blogs entry in the ordered set where uuid = &#63;.
270            *
271            * <p>
272            * 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.
273            * </p>
274            *
275            * @param uuid the uuid to search with
276            * @param orderByComparator the comparator to order the set by
277            * @return the last matching blogs entry
278            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
279            * @throws SystemException if a system exception occurred
280            */
281            public static com.liferay.portlet.blogs.model.BlogsEntry findByUuid_Last(
282                    java.lang.String uuid,
283                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
284                    throws com.liferay.portal.kernel.exception.SystemException,
285                            com.liferay.portlet.blogs.NoSuchEntryException {
286                    return getPersistence().findByUuid_Last(uuid, orderByComparator);
287            }
288    
289            /**
290            * Finds the blogs entries before and after the current blogs entry in the ordered set where uuid = &#63;.
291            *
292            * <p>
293            * 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.
294            * </p>
295            *
296            * @param entryId the primary key of the current blogs entry
297            * @param uuid the uuid to search with
298            * @param orderByComparator the comparator to order the set by
299            * @return the previous, current, and next blogs entry
300            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
301            * @throws SystemException if a system exception occurred
302            */
303            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByUuid_PrevAndNext(
304                    long entryId, java.lang.String uuid,
305                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
306                    throws com.liferay.portal.kernel.exception.SystemException,
307                            com.liferay.portlet.blogs.NoSuchEntryException {
308                    return getPersistence()
309                                       .findByUuid_PrevAndNext(entryId, uuid, orderByComparator);
310            }
311    
312            /**
313            * Finds the blogs entry where uuid = &#63; and groupId = &#63; or throws a {@link com.liferay.portlet.blogs.NoSuchEntryException} if it could not be found.
314            *
315            * @param uuid the uuid to search with
316            * @param groupId the group id to search with
317            * @return the matching blogs entry
318            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
319            * @throws SystemException if a system exception occurred
320            */
321            public static com.liferay.portlet.blogs.model.BlogsEntry findByUUID_G(
322                    java.lang.String uuid, long groupId)
323                    throws com.liferay.portal.kernel.exception.SystemException,
324                            com.liferay.portlet.blogs.NoSuchEntryException {
325                    return getPersistence().findByUUID_G(uuid, groupId);
326            }
327    
328            /**
329            * Finds the blogs entry where uuid = &#63; and groupId = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
330            *
331            * @param uuid the uuid to search with
332            * @param groupId the group id to search with
333            * @return the matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
334            * @throws SystemException if a system exception occurred
335            */
336            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByUUID_G(
337                    java.lang.String uuid, long groupId)
338                    throws com.liferay.portal.kernel.exception.SystemException {
339                    return getPersistence().fetchByUUID_G(uuid, groupId);
340            }
341    
342            /**
343            * Finds 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.
344            *
345            * @param uuid the uuid to search with
346            * @param groupId the group id to search with
347            * @return the matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
348            * @throws SystemException if a system exception occurred
349            */
350            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByUUID_G(
351                    java.lang.String uuid, long groupId, boolean retrieveFromCache)
352                    throws com.liferay.portal.kernel.exception.SystemException {
353                    return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache);
354            }
355    
356            /**
357            * Finds all the blogs entries where groupId = &#63;.
358            *
359            * @param groupId the group id to search with
360            * @return the matching blogs entries
361            * @throws SystemException if a system exception occurred
362            */
363            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByGroupId(
364                    long groupId)
365                    throws com.liferay.portal.kernel.exception.SystemException {
366                    return getPersistence().findByGroupId(groupId);
367            }
368    
369            /**
370            * Finds a range of all the blogs entries where groupId = &#63;.
371            *
372            * <p>
373            * 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.
374            * </p>
375            *
376            * @param groupId the group id to search with
377            * @param start the lower bound of the range of blogs entries to return
378            * @param end the upper bound of the range of blogs entries to return (not inclusive)
379            * @return the range of matching blogs entries
380            * @throws SystemException if a system exception occurred
381            */
382            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByGroupId(
383                    long groupId, int start, int end)
384                    throws com.liferay.portal.kernel.exception.SystemException {
385                    return getPersistence().findByGroupId(groupId, start, end);
386            }
387    
388            /**
389            * Finds an ordered range of all the blogs entries where groupId = &#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 groupId the group id to search with
396            * @param start the lower bound of the range of blogs entries to return
397            * @param end the upper bound of the range of blogs entries to return (not inclusive)
398            * @param orderByComparator the comparator to order the results by
399            * @return the ordered 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> findByGroupId(
403                    long groupId, int start, int end,
404                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
405                    throws com.liferay.portal.kernel.exception.SystemException {
406                    return getPersistence()
407                                       .findByGroupId(groupId, start, end, orderByComparator);
408            }
409    
410            /**
411            * Finds the first blogs entry in the ordered set where groupId = &#63;.
412            *
413            * <p>
414            * 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.
415            * </p>
416            *
417            * @param groupId the group id to search with
418            * @param orderByComparator the comparator to order the set by
419            * @return the first matching blogs entry
420            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
421            * @throws SystemException if a system exception occurred
422            */
423            public static com.liferay.portlet.blogs.model.BlogsEntry findByGroupId_First(
424                    long groupId,
425                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
426                    throws com.liferay.portal.kernel.exception.SystemException,
427                            com.liferay.portlet.blogs.NoSuchEntryException {
428                    return getPersistence().findByGroupId_First(groupId, orderByComparator);
429            }
430    
431            /**
432            * Finds the last blogs entry in the ordered set where groupId = &#63;.
433            *
434            * <p>
435            * 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.
436            * </p>
437            *
438            * @param groupId the group id to search with
439            * @param orderByComparator the comparator to order the set by
440            * @return the last matching blogs entry
441            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
442            * @throws SystemException if a system exception occurred
443            */
444            public static com.liferay.portlet.blogs.model.BlogsEntry findByGroupId_Last(
445                    long groupId,
446                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
447                    throws com.liferay.portal.kernel.exception.SystemException,
448                            com.liferay.portlet.blogs.NoSuchEntryException {
449                    return getPersistence().findByGroupId_Last(groupId, orderByComparator);
450            }
451    
452            /**
453            * Finds the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63;.
454            *
455            * <p>
456            * 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.
457            * </p>
458            *
459            * @param entryId the primary key of the current blogs entry
460            * @param groupId the group id to search with
461            * @param orderByComparator the comparator to order the set by
462            * @return the previous, current, and next blogs entry
463            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
464            * @throws SystemException if a system exception occurred
465            */
466            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByGroupId_PrevAndNext(
467                    long entryId, long groupId,
468                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
469                    throws com.liferay.portal.kernel.exception.SystemException,
470                            com.liferay.portlet.blogs.NoSuchEntryException {
471                    return getPersistence()
472                                       .findByGroupId_PrevAndNext(entryId, groupId,
473                            orderByComparator);
474            }
475    
476            /**
477            * Filters by the user's permissions and finds all the blogs entries where groupId = &#63;.
478            *
479            * @param groupId the group id to search with
480            * @return the matching blogs entries that the user has permission to view
481            * @throws SystemException if a system exception occurred
482            */
483            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByGroupId(
484                    long groupId)
485                    throws com.liferay.portal.kernel.exception.SystemException {
486                    return getPersistence().filterFindByGroupId(groupId);
487            }
488    
489            /**
490            * Filters by the user's permissions and finds a range of all the blogs entries where groupId = &#63;.
491            *
492            * <p>
493            * 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.
494            * </p>
495            *
496            * @param groupId the group id to search with
497            * @param start the lower bound of the range of blogs entries to return
498            * @param end the upper bound of the range of blogs entries to return (not inclusive)
499            * @return the range of matching blogs entries that the user has permission to view
500            * @throws SystemException if a system exception occurred
501            */
502            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByGroupId(
503                    long groupId, int start, int end)
504                    throws com.liferay.portal.kernel.exception.SystemException {
505                    return getPersistence().filterFindByGroupId(groupId, start, end);
506            }
507    
508            /**
509            * Filters by the user's permissions and finds an ordered range of all the blogs entries where groupId = &#63;.
510            *
511            * <p>
512            * 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.
513            * </p>
514            *
515            * @param groupId the group id to search with
516            * @param start the lower bound of the range of blogs entries to return
517            * @param end the upper bound of the range of blogs entries to return (not inclusive)
518            * @param orderByComparator the comparator to order the results by
519            * @return the ordered range of matching blogs entries that the user has permission to view
520            * @throws SystemException if a system exception occurred
521            */
522            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByGroupId(
523                    long groupId, int start, int end,
524                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
525                    throws com.liferay.portal.kernel.exception.SystemException {
526                    return getPersistence()
527                                       .filterFindByGroupId(groupId, start, end, orderByComparator);
528            }
529    
530            /**
531            * Finds all the blogs entries where companyId = &#63;.
532            *
533            * @param companyId the company id to search with
534            * @return the matching blogs entries
535            * @throws SystemException if a system exception occurred
536            */
537            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByCompanyId(
538                    long companyId)
539                    throws com.liferay.portal.kernel.exception.SystemException {
540                    return getPersistence().findByCompanyId(companyId);
541            }
542    
543            /**
544            * Finds a range of all the blogs entries where companyId = &#63;.
545            *
546            * <p>
547            * 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.
548            * </p>
549            *
550            * @param companyId the company id to search with
551            * @param start the lower bound of the range of blogs entries to return
552            * @param end the upper bound of the range of blogs entries to return (not inclusive)
553            * @return the range of matching blogs entries
554            * @throws SystemException if a system exception occurred
555            */
556            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByCompanyId(
557                    long companyId, int start, int end)
558                    throws com.liferay.portal.kernel.exception.SystemException {
559                    return getPersistence().findByCompanyId(companyId, start, end);
560            }
561    
562            /**
563            * Finds an ordered range of all the blogs entries where companyId = &#63;.
564            *
565            * <p>
566            * 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.
567            * </p>
568            *
569            * @param companyId the company id to search with
570            * @param start the lower bound of the range of blogs entries to return
571            * @param end the upper bound of the range of blogs entries to return (not inclusive)
572            * @param orderByComparator the comparator to order the results by
573            * @return the ordered range of matching blogs entries
574            * @throws SystemException if a system exception occurred
575            */
576            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByCompanyId(
577                    long companyId, int start, int end,
578                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
579                    throws com.liferay.portal.kernel.exception.SystemException {
580                    return getPersistence()
581                                       .findByCompanyId(companyId, start, end, orderByComparator);
582            }
583    
584            /**
585            * Finds the first blogs entry in the ordered set where companyId = &#63;.
586            *
587            * <p>
588            * 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.
589            * </p>
590            *
591            * @param companyId the company id to search with
592            * @param orderByComparator the comparator to order the set by
593            * @return the first matching blogs entry
594            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
595            * @throws SystemException if a system exception occurred
596            */
597            public static com.liferay.portlet.blogs.model.BlogsEntry findByCompanyId_First(
598                    long companyId,
599                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
600                    throws com.liferay.portal.kernel.exception.SystemException,
601                            com.liferay.portlet.blogs.NoSuchEntryException {
602                    return getPersistence()
603                                       .findByCompanyId_First(companyId, orderByComparator);
604            }
605    
606            /**
607            * Finds the last blogs entry in the ordered set where companyId = &#63;.
608            *
609            * <p>
610            * 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.
611            * </p>
612            *
613            * @param companyId the company id to search with
614            * @param orderByComparator the comparator to order the set by
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 findByCompanyId_Last(
620                    long companyId,
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()
625                                       .findByCompanyId_Last(companyId, orderByComparator);
626            }
627    
628            /**
629            * Finds the blogs entries before and after the current blogs entry in the ordered set where companyId = &#63;.
630            *
631            * <p>
632            * 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.
633            * </p>
634            *
635            * @param entryId the primary key of the current blogs entry
636            * @param companyId the company id to search with
637            * @param orderByComparator the comparator to order the set by
638            * @return the previous, current, and next blogs entry
639            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
640            * @throws SystemException if a system exception occurred
641            */
642            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByCompanyId_PrevAndNext(
643                    long entryId, long companyId,
644                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
645                    throws com.liferay.portal.kernel.exception.SystemException,
646                            com.liferay.portlet.blogs.NoSuchEntryException {
647                    return getPersistence()
648                                       .findByCompanyId_PrevAndNext(entryId, companyId,
649                            orderByComparator);
650            }
651    
652            /**
653            * Finds all the blogs entries where companyId = &#63; and userId = &#63;.
654            *
655            * @param companyId the company id to search with
656            * @param userId the user id to search with
657            * @return the matching blogs entries
658            * @throws SystemException if a system exception occurred
659            */
660            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_U(
661                    long companyId, long userId)
662                    throws com.liferay.portal.kernel.exception.SystemException {
663                    return getPersistence().findByC_U(companyId, userId);
664            }
665    
666            /**
667            * Finds a range of all the blogs entries where companyId = &#63; and userId = &#63;.
668            *
669            * <p>
670            * 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.
671            * </p>
672            *
673            * @param companyId the company id to search with
674            * @param userId the user id to search with
675            * @param start the lower bound of the range of blogs entries to return
676            * @param end the upper bound of the range of blogs entries to return (not inclusive)
677            * @return the range of matching blogs entries
678            * @throws SystemException if a system exception occurred
679            */
680            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_U(
681                    long companyId, long userId, int start, int end)
682                    throws com.liferay.portal.kernel.exception.SystemException {
683                    return getPersistence().findByC_U(companyId, userId, start, end);
684            }
685    
686            /**
687            * Finds an ordered range of all the blogs entries where companyId = &#63; and userId = &#63;.
688            *
689            * <p>
690            * 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.
691            * </p>
692            *
693            * @param companyId the company id to search with
694            * @param userId the user id to search with
695            * @param start the lower bound of the range of blogs entries to return
696            * @param end the upper bound of the range of blogs entries to return (not inclusive)
697            * @param orderByComparator the comparator to order the results by
698            * @return the ordered range of matching blogs entries
699            * @throws SystemException if a system exception occurred
700            */
701            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_U(
702                    long companyId, long userId, int start, int end,
703                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
704                    throws com.liferay.portal.kernel.exception.SystemException {
705                    return getPersistence()
706                                       .findByC_U(companyId, userId, start, end, orderByComparator);
707            }
708    
709            /**
710            * Finds the first blogs entry in the ordered set where companyId = &#63; and userId = &#63;.
711            *
712            * <p>
713            * 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.
714            * </p>
715            *
716            * @param companyId the company id to search with
717            * @param userId the user id to search with
718            * @param orderByComparator the comparator to order the set by
719            * @return the first matching blogs entry
720            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
721            * @throws SystemException if a system exception occurred
722            */
723            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_U_First(
724                    long companyId, long userId,
725                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
726                    throws com.liferay.portal.kernel.exception.SystemException,
727                            com.liferay.portlet.blogs.NoSuchEntryException {
728                    return getPersistence()
729                                       .findByC_U_First(companyId, userId, orderByComparator);
730            }
731    
732            /**
733            * Finds the last blogs entry in the ordered set where companyId = &#63; and userId = &#63;.
734            *
735            * <p>
736            * 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.
737            * </p>
738            *
739            * @param companyId the company id to search with
740            * @param userId the user id to search with
741            * @param orderByComparator the comparator to order the set by
742            * @return the last matching blogs entry
743            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
744            * @throws SystemException if a system exception occurred
745            */
746            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_U_Last(
747                    long companyId, long userId,
748                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
749                    throws com.liferay.portal.kernel.exception.SystemException,
750                            com.liferay.portlet.blogs.NoSuchEntryException {
751                    return getPersistence()
752                                       .findByC_U_Last(companyId, userId, orderByComparator);
753            }
754    
755            /**
756            * Finds the blogs entries before and after the current blogs entry in the ordered set where companyId = &#63; and userId = &#63;.
757            *
758            * <p>
759            * 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.
760            * </p>
761            *
762            * @param entryId the primary key of the current blogs entry
763            * @param companyId the company id to search with
764            * @param userId the user id to search with
765            * @param orderByComparator the comparator to order the set by
766            * @return the previous, current, and next blogs entry
767            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
768            * @throws SystemException if a system exception occurred
769            */
770            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByC_U_PrevAndNext(
771                    long entryId, long companyId, long userId,
772                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
773                    throws com.liferay.portal.kernel.exception.SystemException,
774                            com.liferay.portlet.blogs.NoSuchEntryException {
775                    return getPersistence()
776                                       .findByC_U_PrevAndNext(entryId, companyId, userId,
777                            orderByComparator);
778            }
779    
780            /**
781            * Finds all the blogs entries where companyId = &#63; and displayDate &lt; &#63;.
782            *
783            * @param companyId the company id to search with
784            * @param displayDate the display date to search with
785            * @return the matching blogs entries
786            * @throws SystemException if a system exception occurred
787            */
788            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_LtD(
789                    long companyId, java.util.Date displayDate)
790                    throws com.liferay.portal.kernel.exception.SystemException {
791                    return getPersistence().findByC_LtD(companyId, displayDate);
792            }
793    
794            /**
795            * Finds a range of all the blogs entries where companyId = &#63; and displayDate &lt; &#63;.
796            *
797            * <p>
798            * 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.
799            * </p>
800            *
801            * @param companyId the company id to search with
802            * @param displayDate the display date to search with
803            * @param start the lower bound of the range of blogs entries to return
804            * @param end the upper bound of the range of blogs entries to return (not inclusive)
805            * @return the range of matching blogs entries
806            * @throws SystemException if a system exception occurred
807            */
808            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_LtD(
809                    long companyId, java.util.Date displayDate, int start, int end)
810                    throws com.liferay.portal.kernel.exception.SystemException {
811                    return getPersistence().findByC_LtD(companyId, displayDate, start, end);
812            }
813    
814            /**
815            * Finds an ordered range of all the blogs entries where companyId = &#63; and displayDate &lt; &#63;.
816            *
817            * <p>
818            * 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.
819            * </p>
820            *
821            * @param companyId the company id to search with
822            * @param displayDate the display date to search with
823            * @param start the lower bound of the range of blogs entries to return
824            * @param end the upper bound of the range of blogs entries to return (not inclusive)
825            * @param orderByComparator the comparator to order the results by
826            * @return the ordered range of matching blogs entries
827            * @throws SystemException if a system exception occurred
828            */
829            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_LtD(
830                    long companyId, java.util.Date displayDate, int start, int end,
831                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
832                    throws com.liferay.portal.kernel.exception.SystemException {
833                    return getPersistence()
834                                       .findByC_LtD(companyId, displayDate, start, end,
835                            orderByComparator);
836            }
837    
838            /**
839            * Finds the first blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63;.
840            *
841            * <p>
842            * 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.
843            * </p>
844            *
845            * @param companyId the company id to search with
846            * @param displayDate the display date to search with
847            * @param orderByComparator the comparator to order the set by
848            * @return the first matching blogs entry
849            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
850            * @throws SystemException if a system exception occurred
851            */
852            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_LtD_First(
853                    long companyId, java.util.Date displayDate,
854                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
855                    throws com.liferay.portal.kernel.exception.SystemException,
856                            com.liferay.portlet.blogs.NoSuchEntryException {
857                    return getPersistence()
858                                       .findByC_LtD_First(companyId, displayDate, orderByComparator);
859            }
860    
861            /**
862            * Finds the last blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63;.
863            *
864            * <p>
865            * 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.
866            * </p>
867            *
868            * @param companyId the company id to search with
869            * @param displayDate the display date to search with
870            * @param orderByComparator the comparator to order the set by
871            * @return the last matching blogs entry
872            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
873            * @throws SystemException if a system exception occurred
874            */
875            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_LtD_Last(
876                    long companyId, java.util.Date displayDate,
877                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
878                    throws com.liferay.portal.kernel.exception.SystemException,
879                            com.liferay.portlet.blogs.NoSuchEntryException {
880                    return getPersistence()
881                                       .findByC_LtD_Last(companyId, displayDate, orderByComparator);
882            }
883    
884            /**
885            * Finds the blogs entries before and after the current blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63;.
886            *
887            * <p>
888            * 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.
889            * </p>
890            *
891            * @param entryId the primary key of the current blogs entry
892            * @param companyId the company id to search with
893            * @param displayDate the display date to search with
894            * @param orderByComparator the comparator to order the set by
895            * @return the previous, current, and next blogs entry
896            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
897            * @throws SystemException if a system exception occurred
898            */
899            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByC_LtD_PrevAndNext(
900                    long entryId, long companyId, java.util.Date displayDate,
901                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
902                    throws com.liferay.portal.kernel.exception.SystemException,
903                            com.liferay.portlet.blogs.NoSuchEntryException {
904                    return getPersistence()
905                                       .findByC_LtD_PrevAndNext(entryId, companyId, displayDate,
906                            orderByComparator);
907            }
908    
909            /**
910            * Finds all the blogs entries where companyId = &#63; and status = &#63;.
911            *
912            * @param companyId the company id to search with
913            * @param status the status to search with
914            * @return the matching blogs entries
915            * @throws SystemException if a system exception occurred
916            */
917            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_S(
918                    long companyId, int status)
919                    throws com.liferay.portal.kernel.exception.SystemException {
920                    return getPersistence().findByC_S(companyId, status);
921            }
922    
923            /**
924            * Finds a range of all the blogs entries where companyId = &#63; and status = &#63;.
925            *
926            * <p>
927            * 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.
928            * </p>
929            *
930            * @param companyId the company id to search with
931            * @param status the status to search with
932            * @param start the lower bound of the range of blogs entries to return
933            * @param end the upper bound of the range of blogs entries to return (not inclusive)
934            * @return the range of matching blogs entries
935            * @throws SystemException if a system exception occurred
936            */
937            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_S(
938                    long companyId, int status, int start, int end)
939                    throws com.liferay.portal.kernel.exception.SystemException {
940                    return getPersistence().findByC_S(companyId, status, start, end);
941            }
942    
943            /**
944            * Finds an ordered range of all the blogs entries where companyId = &#63; and status = &#63;.
945            *
946            * <p>
947            * 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.
948            * </p>
949            *
950            * @param companyId the company id to search with
951            * @param status the status to search with
952            * @param start the lower bound of the range of blogs entries to return
953            * @param end the upper bound of the range of blogs entries to return (not inclusive)
954            * @param orderByComparator the comparator to order the results by
955            * @return the ordered range of matching blogs entries
956            * @throws SystemException if a system exception occurred
957            */
958            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_S(
959                    long companyId, int status, int start, int end,
960                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
961                    throws com.liferay.portal.kernel.exception.SystemException {
962                    return getPersistence()
963                                       .findByC_S(companyId, status, start, end, orderByComparator);
964            }
965    
966            /**
967            * Finds the first blogs entry in the ordered set where companyId = &#63; and status = &#63;.
968            *
969            * <p>
970            * 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.
971            * </p>
972            *
973            * @param companyId the company id to search with
974            * @param status the status to search with
975            * @param orderByComparator the comparator to order the set by
976            * @return the first matching blogs entry
977            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
978            * @throws SystemException if a system exception occurred
979            */
980            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_S_First(
981                    long companyId, int status,
982                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
983                    throws com.liferay.portal.kernel.exception.SystemException,
984                            com.liferay.portlet.blogs.NoSuchEntryException {
985                    return getPersistence()
986                                       .findByC_S_First(companyId, status, orderByComparator);
987            }
988    
989            /**
990            * Finds the last blogs entry in the ordered set where companyId = &#63; and status = &#63;.
991            *
992            * <p>
993            * 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.
994            * </p>
995            *
996            * @param companyId the company id to search with
997            * @param status the status to search with
998            * @param orderByComparator the comparator to order the set by
999            * @return the last matching blogs entry
1000            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1001            * @throws SystemException if a system exception occurred
1002            */
1003            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_S_Last(
1004                    long companyId, int status,
1005                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1006                    throws com.liferay.portal.kernel.exception.SystemException,
1007                            com.liferay.portlet.blogs.NoSuchEntryException {
1008                    return getPersistence()
1009                                       .findByC_S_Last(companyId, status, orderByComparator);
1010            }
1011    
1012            /**
1013            * Finds the blogs entries before and after the current blogs entry in the ordered set where companyId = &#63; and status = &#63;.
1014            *
1015            * <p>
1016            * 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.
1017            * </p>
1018            *
1019            * @param entryId the primary key of the current blogs entry
1020            * @param companyId the company id to search with
1021            * @param status the status to search with
1022            * @param orderByComparator the comparator to order the set by
1023            * @return the previous, current, and next blogs entry
1024            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
1025            * @throws SystemException if a system exception occurred
1026            */
1027            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByC_S_PrevAndNext(
1028                    long entryId, long companyId, int status,
1029                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1030                    throws com.liferay.portal.kernel.exception.SystemException,
1031                            com.liferay.portlet.blogs.NoSuchEntryException {
1032                    return getPersistence()
1033                                       .findByC_S_PrevAndNext(entryId, companyId, status,
1034                            orderByComparator);
1035            }
1036    
1037            /**
1038            * Finds the blogs entry where groupId = &#63; and urlTitle = &#63; or throws a {@link com.liferay.portlet.blogs.NoSuchEntryException} if it could not be found.
1039            *
1040            * @param groupId the group id to search with
1041            * @param urlTitle the url title to search with
1042            * @return the matching blogs entry
1043            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1044            * @throws SystemException if a system exception occurred
1045            */
1046            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_UT(
1047                    long groupId, java.lang.String urlTitle)
1048                    throws com.liferay.portal.kernel.exception.SystemException,
1049                            com.liferay.portlet.blogs.NoSuchEntryException {
1050                    return getPersistence().findByG_UT(groupId, urlTitle);
1051            }
1052    
1053            /**
1054            * Finds the blogs entry where groupId = &#63; and urlTitle = &#63; or returns <code>null</code> if it could not be found. Uses the finder cache.
1055            *
1056            * @param groupId the group id to search with
1057            * @param urlTitle the url title to search with
1058            * @return the matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
1059            * @throws SystemException if a system exception occurred
1060            */
1061            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_UT(
1062                    long groupId, java.lang.String urlTitle)
1063                    throws com.liferay.portal.kernel.exception.SystemException {
1064                    return getPersistence().fetchByG_UT(groupId, urlTitle);
1065            }
1066    
1067            /**
1068            * Finds 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.
1069            *
1070            * @param groupId the group id to search with
1071            * @param urlTitle the url title to search with
1072            * @return the matching blogs entry, or <code>null</code> if a matching blogs entry could not be found
1073            * @throws SystemException if a system exception occurred
1074            */
1075            public static com.liferay.portlet.blogs.model.BlogsEntry fetchByG_UT(
1076                    long groupId, java.lang.String urlTitle, boolean retrieveFromCache)
1077                    throws com.liferay.portal.kernel.exception.SystemException {
1078                    return getPersistence().fetchByG_UT(groupId, urlTitle, retrieveFromCache);
1079            }
1080    
1081            /**
1082            * Finds all the blogs entries where groupId = &#63; and displayDate &lt; &#63;.
1083            *
1084            * @param groupId the group id to search with
1085            * @param displayDate the display date to search with
1086            * @return the matching blogs entries
1087            * @throws SystemException if a system exception occurred
1088            */
1089            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_LtD(
1090                    long groupId, java.util.Date displayDate)
1091                    throws com.liferay.portal.kernel.exception.SystemException {
1092                    return getPersistence().findByG_LtD(groupId, displayDate);
1093            }
1094    
1095            /**
1096            * Finds a range of all the blogs entries where groupId = &#63; and displayDate &lt; &#63;.
1097            *
1098            * <p>
1099            * 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.
1100            * </p>
1101            *
1102            * @param groupId the group id to search with
1103            * @param displayDate the display date to search with
1104            * @param start the lower bound of the range of blogs entries to return
1105            * @param end the upper bound of the range of blogs entries to return (not inclusive)
1106            * @return the range of matching blogs entries
1107            * @throws SystemException if a system exception occurred
1108            */
1109            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_LtD(
1110                    long groupId, java.util.Date displayDate, int start, int end)
1111                    throws com.liferay.portal.kernel.exception.SystemException {
1112                    return getPersistence().findByG_LtD(groupId, displayDate, start, end);
1113            }
1114    
1115            /**
1116            * Finds an ordered range of all the blogs entries where groupId = &#63; and displayDate &lt; &#63;.
1117            *
1118            * <p>
1119            * 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.
1120            * </p>
1121            *
1122            * @param groupId the group id to search with
1123            * @param displayDate the display date to search with
1124            * @param start the lower bound of the range of blogs entries to return
1125            * @param end the upper bound of the range of blogs entries to return (not inclusive)
1126            * @param orderByComparator the comparator to order the results by
1127            * @return the ordered range of matching blogs entries
1128            * @throws SystemException if a system exception occurred
1129            */
1130            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_LtD(
1131                    long groupId, java.util.Date displayDate, int start, int end,
1132                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1133                    throws com.liferay.portal.kernel.exception.SystemException {
1134                    return getPersistence()
1135                                       .findByG_LtD(groupId, displayDate, start, end,
1136                            orderByComparator);
1137            }
1138    
1139            /**
1140            * Finds the first blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63;.
1141            *
1142            * <p>
1143            * 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.
1144            * </p>
1145            *
1146            * @param groupId the group id to search with
1147            * @param displayDate the display date to search with
1148            * @param orderByComparator the comparator to order the set by
1149            * @return the first matching blogs entry
1150            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1151            * @throws SystemException if a system exception occurred
1152            */
1153            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_LtD_First(
1154                    long groupId, java.util.Date displayDate,
1155                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1156                    throws com.liferay.portal.kernel.exception.SystemException,
1157                            com.liferay.portlet.blogs.NoSuchEntryException {
1158                    return getPersistence()
1159                                       .findByG_LtD_First(groupId, displayDate, orderByComparator);
1160            }
1161    
1162            /**
1163            * Finds the last blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63;.
1164            *
1165            * <p>
1166            * 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.
1167            * </p>
1168            *
1169            * @param groupId the group id to search with
1170            * @param displayDate the display date to search with
1171            * @param orderByComparator the comparator to order the set by
1172            * @return the last matching blogs entry
1173            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1174            * @throws SystemException if a system exception occurred
1175            */
1176            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_LtD_Last(
1177                    long groupId, java.util.Date displayDate,
1178                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1179                    throws com.liferay.portal.kernel.exception.SystemException,
1180                            com.liferay.portlet.blogs.NoSuchEntryException {
1181                    return getPersistence()
1182                                       .findByG_LtD_Last(groupId, displayDate, orderByComparator);
1183            }
1184    
1185            /**
1186            * Finds the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63;.
1187            *
1188            * <p>
1189            * 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.
1190            * </p>
1191            *
1192            * @param entryId the primary key of the current blogs entry
1193            * @param groupId the group id to search with
1194            * @param displayDate the display date to search with
1195            * @param orderByComparator the comparator to order the set by
1196            * @return the previous, current, and next blogs entry
1197            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
1198            * @throws SystemException if a system exception occurred
1199            */
1200            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByG_LtD_PrevAndNext(
1201                    long entryId, long groupId, java.util.Date displayDate,
1202                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1203                    throws com.liferay.portal.kernel.exception.SystemException,
1204                            com.liferay.portlet.blogs.NoSuchEntryException {
1205                    return getPersistence()
1206                                       .findByG_LtD_PrevAndNext(entryId, groupId, displayDate,
1207                            orderByComparator);
1208            }
1209    
1210            /**
1211            * Filters by the user's permissions and finds all the blogs entries where groupId = &#63; and displayDate &lt; &#63;.
1212            *
1213            * @param groupId the group id to search with
1214            * @param displayDate the display date to search with
1215            * @return the matching blogs entries that the user has permission to view
1216            * @throws SystemException if a system exception occurred
1217            */
1218            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_LtD(
1219                    long groupId, java.util.Date displayDate)
1220                    throws com.liferay.portal.kernel.exception.SystemException {
1221                    return getPersistence().filterFindByG_LtD(groupId, displayDate);
1222            }
1223    
1224            /**
1225            * Filters by the user's permissions and finds a range of all the blogs entries where groupId = &#63; and displayDate &lt; &#63;.
1226            *
1227            * <p>
1228            * 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.
1229            * </p>
1230            *
1231            * @param groupId the group id to search with
1232            * @param displayDate the display date to search with
1233            * @param start the lower bound of the range of blogs entries to return
1234            * @param end the upper bound of the range of blogs entries to return (not inclusive)
1235            * @return the range of matching blogs entries that the user has permission to view
1236            * @throws SystemException if a system exception occurred
1237            */
1238            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_LtD(
1239                    long groupId, java.util.Date displayDate, int start, int end)
1240                    throws com.liferay.portal.kernel.exception.SystemException {
1241                    return getPersistence()
1242                                       .filterFindByG_LtD(groupId, displayDate, start, end);
1243            }
1244    
1245            /**
1246            * Filters by the user's permissions and finds an ordered range of all the blogs entries where groupId = &#63; and displayDate &lt; &#63;.
1247            *
1248            * <p>
1249            * 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.
1250            * </p>
1251            *
1252            * @param groupId the group id to search with
1253            * @param displayDate the display date to search with
1254            * @param start the lower bound of the range of blogs entries to return
1255            * @param end the upper bound of the range of blogs entries to return (not inclusive)
1256            * @param orderByComparator the comparator to order the results by
1257            * @return the ordered range of matching blogs entries that the user has permission to view
1258            * @throws SystemException if a system exception occurred
1259            */
1260            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_LtD(
1261                    long groupId, java.util.Date displayDate, int start, int end,
1262                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1263                    throws com.liferay.portal.kernel.exception.SystemException {
1264                    return getPersistence()
1265                                       .filterFindByG_LtD(groupId, displayDate, start, end,
1266                            orderByComparator);
1267            }
1268    
1269            /**
1270            * Finds all the blogs entries where groupId = &#63; and status = &#63;.
1271            *
1272            * @param groupId the group id to search with
1273            * @param status the status to search with
1274            * @return the matching blogs entries
1275            * @throws SystemException if a system exception occurred
1276            */
1277            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_S(
1278                    long groupId, int status)
1279                    throws com.liferay.portal.kernel.exception.SystemException {
1280                    return getPersistence().findByG_S(groupId, status);
1281            }
1282    
1283            /**
1284            * Finds a range of all the blogs entries where groupId = &#63; and status = &#63;.
1285            *
1286            * <p>
1287            * 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.
1288            * </p>
1289            *
1290            * @param groupId the group id to search with
1291            * @param status the status to search with
1292            * @param start the lower bound of the range of blogs entries to return
1293            * @param end the upper bound of the range of blogs entries to return (not inclusive)
1294            * @return the range of matching blogs entries
1295            * @throws SystemException if a system exception occurred
1296            */
1297            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_S(
1298                    long groupId, int status, int start, int end)
1299                    throws com.liferay.portal.kernel.exception.SystemException {
1300                    return getPersistence().findByG_S(groupId, status, start, end);
1301            }
1302    
1303            /**
1304            * Finds an ordered range of all the blogs entries where groupId = &#63; and status = &#63;.
1305            *
1306            * <p>
1307            * 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.
1308            * </p>
1309            *
1310            * @param groupId the group id to search with
1311            * @param status the status to search with
1312            * @param start the lower bound of the range of blogs entries to return
1313            * @param end the upper bound of the range of blogs entries to return (not inclusive)
1314            * @param orderByComparator the comparator to order the results by
1315            * @return the ordered range of matching blogs entries
1316            * @throws SystemException if a system exception occurred
1317            */
1318            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_S(
1319                    long groupId, int status, int start, int end,
1320                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1321                    throws com.liferay.portal.kernel.exception.SystemException {
1322                    return getPersistence()
1323                                       .findByG_S(groupId, status, start, end, orderByComparator);
1324            }
1325    
1326            /**
1327            * Finds the first blogs entry in the ordered set where groupId = &#63; and status = &#63;.
1328            *
1329            * <p>
1330            * 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.
1331            * </p>
1332            *
1333            * @param groupId the group id to search with
1334            * @param status the status to search with
1335            * @param orderByComparator the comparator to order the set by
1336            * @return the first matching blogs entry
1337            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1338            * @throws SystemException if a system exception occurred
1339            */
1340            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_S_First(
1341                    long groupId, int status,
1342                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1343                    throws com.liferay.portal.kernel.exception.SystemException,
1344                            com.liferay.portlet.blogs.NoSuchEntryException {
1345                    return getPersistence()
1346                                       .findByG_S_First(groupId, status, orderByComparator);
1347            }
1348    
1349            /**
1350            * Finds the last blogs entry in the ordered set where groupId = &#63; and status = &#63;.
1351            *
1352            * <p>
1353            * 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.
1354            * </p>
1355            *
1356            * @param groupId the group id to search with
1357            * @param status the status to search with
1358            * @param orderByComparator the comparator to order the set by
1359            * @return the last matching blogs entry
1360            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1361            * @throws SystemException if a system exception occurred
1362            */
1363            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_S_Last(
1364                    long groupId, int status,
1365                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1366                    throws com.liferay.portal.kernel.exception.SystemException,
1367                            com.liferay.portlet.blogs.NoSuchEntryException {
1368                    return getPersistence()
1369                                       .findByG_S_Last(groupId, status, orderByComparator);
1370            }
1371    
1372            /**
1373            * Finds the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63; and status = &#63;.
1374            *
1375            * <p>
1376            * 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.
1377            * </p>
1378            *
1379            * @param entryId the primary key of the current blogs entry
1380            * @param groupId the group id to search with
1381            * @param status the status to search with
1382            * @param orderByComparator the comparator to order the set by
1383            * @return the previous, current, and next blogs entry
1384            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
1385            * @throws SystemException if a system exception occurred
1386            */
1387            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByG_S_PrevAndNext(
1388                    long entryId, long groupId, int status,
1389                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1390                    throws com.liferay.portal.kernel.exception.SystemException,
1391                            com.liferay.portlet.blogs.NoSuchEntryException {
1392                    return getPersistence()
1393                                       .findByG_S_PrevAndNext(entryId, groupId, status,
1394                            orderByComparator);
1395            }
1396    
1397            /**
1398            * Filters by the user's permissions and finds all the blogs entries where groupId = &#63; and status = &#63;.
1399            *
1400            * @param groupId the group id to search with
1401            * @param status the status to search with
1402            * @return the matching blogs entries that the user has permission to view
1403            * @throws SystemException if a system exception occurred
1404            */
1405            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_S(
1406                    long groupId, int status)
1407                    throws com.liferay.portal.kernel.exception.SystemException {
1408                    return getPersistence().filterFindByG_S(groupId, status);
1409            }
1410    
1411            /**
1412            * Filters by the user's permissions and finds a range of all the blogs entries where groupId = &#63; and status = &#63;.
1413            *
1414            * <p>
1415            * 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.
1416            * </p>
1417            *
1418            * @param groupId the group id to search with
1419            * @param status the status to search with
1420            * @param start the lower bound of the range of blogs entries to return
1421            * @param end the upper bound of the range of blogs entries to return (not inclusive)
1422            * @return the range of matching blogs entries that the user has permission to view
1423            * @throws SystemException if a system exception occurred
1424            */
1425            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_S(
1426                    long groupId, int status, int start, int end)
1427                    throws com.liferay.portal.kernel.exception.SystemException {
1428                    return getPersistence().filterFindByG_S(groupId, status, start, end);
1429            }
1430    
1431            /**
1432            * Filters by the user's permissions and finds an ordered range of all the blogs entries where groupId = &#63; and status = &#63;.
1433            *
1434            * <p>
1435            * 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.
1436            * </p>
1437            *
1438            * @param groupId the group id to search with
1439            * @param status the status to search with
1440            * @param start the lower bound of the range of blogs entries to return
1441            * @param end the upper bound of the range of blogs entries to return (not inclusive)
1442            * @param orderByComparator the comparator to order the results by
1443            * @return the ordered range of matching blogs entries that the user has permission to view
1444            * @throws SystemException if a system exception occurred
1445            */
1446            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_S(
1447                    long groupId, int status, int start, int end,
1448                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1449                    throws com.liferay.portal.kernel.exception.SystemException {
1450                    return getPersistence()
1451                                       .filterFindByG_S(groupId, status, start, end,
1452                            orderByComparator);
1453            }
1454    
1455            /**
1456            * Finds all the blogs entries where companyId = &#63; and userId = &#63; and status = &#63;.
1457            *
1458            * @param companyId the company id to search with
1459            * @param userId the user id to search with
1460            * @param status the status to search with
1461            * @return the matching blogs entries
1462            * @throws SystemException if a system exception occurred
1463            */
1464            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_U_S(
1465                    long companyId, long userId, int status)
1466                    throws com.liferay.portal.kernel.exception.SystemException {
1467                    return getPersistence().findByC_U_S(companyId, userId, status);
1468            }
1469    
1470            /**
1471            * Finds a range of all the blogs entries where companyId = &#63; and userId = &#63; and status = &#63;.
1472            *
1473            * <p>
1474            * 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.
1475            * </p>
1476            *
1477            * @param companyId the company id to search with
1478            * @param userId the user id to search with
1479            * @param status the status to search with
1480            * @param start the lower bound of the range of blogs entries to return
1481            * @param end the upper bound of the range of blogs entries to return (not inclusive)
1482            * @return the range of matching blogs entries
1483            * @throws SystemException if a system exception occurred
1484            */
1485            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_U_S(
1486                    long companyId, long userId, int status, int start, int end)
1487                    throws com.liferay.portal.kernel.exception.SystemException {
1488                    return getPersistence()
1489                                       .findByC_U_S(companyId, userId, status, start, end);
1490            }
1491    
1492            /**
1493            * Finds an ordered range of all the blogs entries where companyId = &#63; and userId = &#63; and status = &#63;.
1494            *
1495            * <p>
1496            * 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.
1497            * </p>
1498            *
1499            * @param companyId the company id to search with
1500            * @param userId the user id to search with
1501            * @param status the status to search with
1502            * @param start the lower bound of the range of blogs entries to return
1503            * @param end the upper bound of the range of blogs entries to return (not inclusive)
1504            * @param orderByComparator the comparator to order the results by
1505            * @return the ordered range of matching blogs entries
1506            * @throws SystemException if a system exception occurred
1507            */
1508            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_U_S(
1509                    long companyId, long userId, int status, int start, int end,
1510                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1511                    throws com.liferay.portal.kernel.exception.SystemException {
1512                    return getPersistence()
1513                                       .findByC_U_S(companyId, userId, status, start, end,
1514                            orderByComparator);
1515            }
1516    
1517            /**
1518            * Finds the first blogs entry in the ordered set where companyId = &#63; and userId = &#63; and status = &#63;.
1519            *
1520            * <p>
1521            * 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.
1522            * </p>
1523            *
1524            * @param companyId the company id to search with
1525            * @param userId the user id to search with
1526            * @param status the status to search with
1527            * @param orderByComparator the comparator to order the set by
1528            * @return the first matching blogs entry
1529            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1530            * @throws SystemException if a system exception occurred
1531            */
1532            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_U_S_First(
1533                    long companyId, long userId, int status,
1534                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1535                    throws com.liferay.portal.kernel.exception.SystemException,
1536                            com.liferay.portlet.blogs.NoSuchEntryException {
1537                    return getPersistence()
1538                                       .findByC_U_S_First(companyId, userId, status,
1539                            orderByComparator);
1540            }
1541    
1542            /**
1543            * Finds the last blogs entry in the ordered set where companyId = &#63; and userId = &#63; and status = &#63;.
1544            *
1545            * <p>
1546            * 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.
1547            * </p>
1548            *
1549            * @param companyId the company id to search with
1550            * @param userId the user id to search with
1551            * @param status the status to search with
1552            * @param orderByComparator the comparator to order the set by
1553            * @return the last matching blogs entry
1554            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1555            * @throws SystemException if a system exception occurred
1556            */
1557            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_U_S_Last(
1558                    long companyId, long userId, int status,
1559                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1560                    throws com.liferay.portal.kernel.exception.SystemException,
1561                            com.liferay.portlet.blogs.NoSuchEntryException {
1562                    return getPersistence()
1563                                       .findByC_U_S_Last(companyId, userId, status,
1564                            orderByComparator);
1565            }
1566    
1567            /**
1568            * Finds the blogs entries before and after the current blogs entry in the ordered set where companyId = &#63; and userId = &#63; and status = &#63;.
1569            *
1570            * <p>
1571            * 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.
1572            * </p>
1573            *
1574            * @param entryId the primary key of the current blogs entry
1575            * @param companyId the company id to search with
1576            * @param userId the user id to search with
1577            * @param status the status to search with
1578            * @param orderByComparator the comparator to order the set by
1579            * @return the previous, current, and next blogs entry
1580            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
1581            * @throws SystemException if a system exception occurred
1582            */
1583            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByC_U_S_PrevAndNext(
1584                    long entryId, long companyId, long userId, int status,
1585                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1586                    throws com.liferay.portal.kernel.exception.SystemException,
1587                            com.liferay.portlet.blogs.NoSuchEntryException {
1588                    return getPersistence()
1589                                       .findByC_U_S_PrevAndNext(entryId, companyId, userId, status,
1590                            orderByComparator);
1591            }
1592    
1593            /**
1594            * Finds all the blogs entries where companyId = &#63; and displayDate &lt; &#63; and status = &#63;.
1595            *
1596            * @param companyId the company id to search with
1597            * @param displayDate the display date to search with
1598            * @param status the status to search with
1599            * @return the matching blogs entries
1600            * @throws SystemException if a system exception occurred
1601            */
1602            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_LtD_S(
1603                    long companyId, java.util.Date displayDate, int status)
1604                    throws com.liferay.portal.kernel.exception.SystemException {
1605                    return getPersistence().findByC_LtD_S(companyId, displayDate, status);
1606            }
1607    
1608            /**
1609            * Finds a range of all the blogs entries where companyId = &#63; and displayDate &lt; &#63; and status = &#63;.
1610            *
1611            * <p>
1612            * 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.
1613            * </p>
1614            *
1615            * @param companyId the company id to search with
1616            * @param displayDate the display date to search with
1617            * @param status the status to search with
1618            * @param start the lower bound of the range of blogs entries to return
1619            * @param end the upper bound of the range of blogs entries to return (not inclusive)
1620            * @return the range of matching blogs entries
1621            * @throws SystemException if a system exception occurred
1622            */
1623            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_LtD_S(
1624                    long companyId, java.util.Date displayDate, int status, int start,
1625                    int end) throws com.liferay.portal.kernel.exception.SystemException {
1626                    return getPersistence()
1627                                       .findByC_LtD_S(companyId, displayDate, status, start, end);
1628            }
1629    
1630            /**
1631            * Finds an ordered range of all the blogs entries where companyId = &#63; and displayDate &lt; &#63; and status = &#63;.
1632            *
1633            * <p>
1634            * 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.
1635            * </p>
1636            *
1637            * @param companyId the company id to search with
1638            * @param displayDate the display date to search with
1639            * @param status the status to search with
1640            * @param start the lower bound of the range of blogs entries to return
1641            * @param end the upper bound of the range of blogs entries to return (not inclusive)
1642            * @param orderByComparator the comparator to order the results by
1643            * @return the ordered range of matching blogs entries
1644            * @throws SystemException if a system exception occurred
1645            */
1646            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByC_LtD_S(
1647                    long companyId, java.util.Date displayDate, int status, int start,
1648                    int end,
1649                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1650                    throws com.liferay.portal.kernel.exception.SystemException {
1651                    return getPersistence()
1652                                       .findByC_LtD_S(companyId, displayDate, status, start, end,
1653                            orderByComparator);
1654            }
1655    
1656            /**
1657            * Finds the first blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63; and status = &#63;.
1658            *
1659            * <p>
1660            * 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.
1661            * </p>
1662            *
1663            * @param companyId the company id to search with
1664            * @param displayDate the display date to search with
1665            * @param status the status to search with
1666            * @param orderByComparator the comparator to order the set by
1667            * @return the first matching blogs entry
1668            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1669            * @throws SystemException if a system exception occurred
1670            */
1671            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_LtD_S_First(
1672                    long companyId, java.util.Date displayDate, int status,
1673                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1674                    throws com.liferay.portal.kernel.exception.SystemException,
1675                            com.liferay.portlet.blogs.NoSuchEntryException {
1676                    return getPersistence()
1677                                       .findByC_LtD_S_First(companyId, displayDate, status,
1678                            orderByComparator);
1679            }
1680    
1681            /**
1682            * Finds the last blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63; and status = &#63;.
1683            *
1684            * <p>
1685            * 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.
1686            * </p>
1687            *
1688            * @param companyId the company id to search with
1689            * @param displayDate the display date to search with
1690            * @param status the status to search with
1691            * @param orderByComparator the comparator to order the set by
1692            * @return the last matching blogs entry
1693            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1694            * @throws SystemException if a system exception occurred
1695            */
1696            public static com.liferay.portlet.blogs.model.BlogsEntry findByC_LtD_S_Last(
1697                    long companyId, java.util.Date displayDate, int status,
1698                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1699                    throws com.liferay.portal.kernel.exception.SystemException,
1700                            com.liferay.portlet.blogs.NoSuchEntryException {
1701                    return getPersistence()
1702                                       .findByC_LtD_S_Last(companyId, displayDate, status,
1703                            orderByComparator);
1704            }
1705    
1706            /**
1707            * Finds the blogs entries before and after the current blogs entry in the ordered set where companyId = &#63; and displayDate &lt; &#63; and status = &#63;.
1708            *
1709            * <p>
1710            * 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.
1711            * </p>
1712            *
1713            * @param entryId the primary key of the current blogs entry
1714            * @param companyId the company id to search with
1715            * @param displayDate the display date to search with
1716            * @param status the status to search with
1717            * @param orderByComparator the comparator to order the set by
1718            * @return the previous, current, and next blogs entry
1719            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
1720            * @throws SystemException if a system exception occurred
1721            */
1722            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByC_LtD_S_PrevAndNext(
1723                    long entryId, long companyId, java.util.Date displayDate, int status,
1724                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1725                    throws com.liferay.portal.kernel.exception.SystemException,
1726                            com.liferay.portlet.blogs.NoSuchEntryException {
1727                    return getPersistence()
1728                                       .findByC_LtD_S_PrevAndNext(entryId, companyId, displayDate,
1729                            status, orderByComparator);
1730            }
1731    
1732            /**
1733            * Finds all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
1734            *
1735            * @param groupId the group id to search with
1736            * @param userId the user id to search with
1737            * @param displayDate the display date to search with
1738            * @return the matching blogs entries
1739            * @throws SystemException if a system exception occurred
1740            */
1741            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_LtD(
1742                    long groupId, long userId, java.util.Date displayDate)
1743                    throws com.liferay.portal.kernel.exception.SystemException {
1744                    return getPersistence().findByG_U_LtD(groupId, userId, displayDate);
1745            }
1746    
1747            /**
1748            * Finds a range of all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
1749            *
1750            * <p>
1751            * 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.
1752            * </p>
1753            *
1754            * @param groupId the group id to search with
1755            * @param userId the user id to search with
1756            * @param displayDate the display date to search with
1757            * @param start the lower bound of the range of blogs entries to return
1758            * @param end the upper bound of the range of blogs entries to return (not inclusive)
1759            * @return the range of matching blogs entries
1760            * @throws SystemException if a system exception occurred
1761            */
1762            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_LtD(
1763                    long groupId, long userId, java.util.Date displayDate, int start,
1764                    int end) throws com.liferay.portal.kernel.exception.SystemException {
1765                    return getPersistence()
1766                                       .findByG_U_LtD(groupId, userId, displayDate, start, end);
1767            }
1768    
1769            /**
1770            * Finds an ordered range of all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#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 to search with
1777            * @param userId the user id to search with
1778            * @param displayDate the display date to search with
1779            * @param start the lower bound of the range of blogs entries to return
1780            * @param end the upper bound of the range of blogs entries to return (not inclusive)
1781            * @param orderByComparator the comparator to order the results by
1782            * @return the ordered range of matching blogs entries
1783            * @throws SystemException if a system exception occurred
1784            */
1785            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_LtD(
1786                    long groupId, long userId, java.util.Date displayDate, int start,
1787                    int end,
1788                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1789                    throws com.liferay.portal.kernel.exception.SystemException {
1790                    return getPersistence()
1791                                       .findByG_U_LtD(groupId, userId, displayDate, start, end,
1792                            orderByComparator);
1793            }
1794    
1795            /**
1796            * Finds the first blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
1797            *
1798            * <p>
1799            * 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.
1800            * </p>
1801            *
1802            * @param groupId the group id to search with
1803            * @param userId the user id to search with
1804            * @param displayDate the display date to search with
1805            * @param orderByComparator the comparator to order the set by
1806            * @return the first matching blogs entry
1807            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1808            * @throws SystemException if a system exception occurred
1809            */
1810            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_U_LtD_First(
1811                    long groupId, long userId, java.util.Date displayDate,
1812                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1813                    throws com.liferay.portal.kernel.exception.SystemException,
1814                            com.liferay.portlet.blogs.NoSuchEntryException {
1815                    return getPersistence()
1816                                       .findByG_U_LtD_First(groupId, userId, displayDate,
1817                            orderByComparator);
1818            }
1819    
1820            /**
1821            * Finds the last blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
1822            *
1823            * <p>
1824            * 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.
1825            * </p>
1826            *
1827            * @param groupId the group id to search with
1828            * @param userId the user id to search with
1829            * @param displayDate the display date to search with
1830            * @param orderByComparator the comparator to order the set by
1831            * @return the last matching blogs entry
1832            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
1833            * @throws SystemException if a system exception occurred
1834            */
1835            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_U_LtD_Last(
1836                    long groupId, long userId, java.util.Date displayDate,
1837                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1838                    throws com.liferay.portal.kernel.exception.SystemException,
1839                            com.liferay.portlet.blogs.NoSuchEntryException {
1840                    return getPersistence()
1841                                       .findByG_U_LtD_Last(groupId, userId, displayDate,
1842                            orderByComparator);
1843            }
1844    
1845            /**
1846            * Finds the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
1847            *
1848            * <p>
1849            * 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.
1850            * </p>
1851            *
1852            * @param entryId the primary key of the current blogs entry
1853            * @param groupId the group id to search with
1854            * @param userId the user id to search with
1855            * @param displayDate the display date to search with
1856            * @param orderByComparator the comparator to order the set by
1857            * @return the previous, current, and next blogs entry
1858            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
1859            * @throws SystemException if a system exception occurred
1860            */
1861            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByG_U_LtD_PrevAndNext(
1862                    long entryId, long groupId, long userId, java.util.Date displayDate,
1863                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1864                    throws com.liferay.portal.kernel.exception.SystemException,
1865                            com.liferay.portlet.blogs.NoSuchEntryException {
1866                    return getPersistence()
1867                                       .findByG_U_LtD_PrevAndNext(entryId, groupId, userId,
1868                            displayDate, orderByComparator);
1869            }
1870    
1871            /**
1872            * Filters by the user's permissions and finds all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
1873            *
1874            * @param groupId the group id to search with
1875            * @param userId the user id to search with
1876            * @param displayDate the display date to search with
1877            * @return the matching blogs entries that the user has permission to view
1878            * @throws SystemException if a system exception occurred
1879            */
1880            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_LtD(
1881                    long groupId, long userId, java.util.Date displayDate)
1882                    throws com.liferay.portal.kernel.exception.SystemException {
1883                    return getPersistence().filterFindByG_U_LtD(groupId, userId, displayDate);
1884            }
1885    
1886            /**
1887            * Filters by the user's permissions and finds a range of all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
1888            *
1889            * <p>
1890            * 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.
1891            * </p>
1892            *
1893            * @param groupId the group id to search with
1894            * @param userId the user id to search with
1895            * @param displayDate the display date to search with
1896            * @param start the lower bound of the range of blogs entries to return
1897            * @param end the upper bound of the range of blogs entries to return (not inclusive)
1898            * @return the range of matching blogs entries that the user has permission to view
1899            * @throws SystemException if a system exception occurred
1900            */
1901            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_LtD(
1902                    long groupId, long userId, java.util.Date displayDate, int start,
1903                    int end) throws com.liferay.portal.kernel.exception.SystemException {
1904                    return getPersistence()
1905                                       .filterFindByG_U_LtD(groupId, userId, displayDate, start, end);
1906            }
1907    
1908            /**
1909            * Filters by the user's permissions and finds an ordered range of all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
1910            *
1911            * <p>
1912            * 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.
1913            * </p>
1914            *
1915            * @param groupId the group id to search with
1916            * @param userId the user id to search with
1917            * @param displayDate the display date to search with
1918            * @param start the lower bound of the range of blogs entries to return
1919            * @param end the upper bound of the range of blogs entries to return (not inclusive)
1920            * @param orderByComparator the comparator to order the results by
1921            * @return the ordered range of matching blogs entries that the user has permission to view
1922            * @throws SystemException if a system exception occurred
1923            */
1924            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_LtD(
1925                    long groupId, long userId, java.util.Date displayDate, int start,
1926                    int end,
1927                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1928                    throws com.liferay.portal.kernel.exception.SystemException {
1929                    return getPersistence()
1930                                       .filterFindByG_U_LtD(groupId, userId, displayDate, start,
1931                            end, orderByComparator);
1932            }
1933    
1934            /**
1935            * Finds all the blogs entries where groupId = &#63; and userId = &#63; and status = &#63;.
1936            *
1937            * @param groupId the group id to search with
1938            * @param userId the user id to search with
1939            * @param status the status to search with
1940            * @return the matching blogs entries
1941            * @throws SystemException if a system exception occurred
1942            */
1943            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_S(
1944                    long groupId, long userId, int status)
1945                    throws com.liferay.portal.kernel.exception.SystemException {
1946                    return getPersistence().findByG_U_S(groupId, userId, status);
1947            }
1948    
1949            /**
1950            * Finds a range of all the blogs entries where groupId = &#63; and userId = &#63; and status = &#63;.
1951            *
1952            * <p>
1953            * 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.
1954            * </p>
1955            *
1956            * @param groupId the group id to search with
1957            * @param userId the user id to search with
1958            * @param status the status to search with
1959            * @param start the lower bound of the range of blogs entries to return
1960            * @param end the upper bound of the range of blogs entries to return (not inclusive)
1961            * @return the range of matching blogs entries
1962            * @throws SystemException if a system exception occurred
1963            */
1964            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_S(
1965                    long groupId, long userId, int status, int start, int end)
1966                    throws com.liferay.portal.kernel.exception.SystemException {
1967                    return getPersistence().findByG_U_S(groupId, userId, status, start, end);
1968            }
1969    
1970            /**
1971            * Finds an ordered range of all the blogs entries where groupId = &#63; and userId = &#63; and status = &#63;.
1972            *
1973            * <p>
1974            * 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.
1975            * </p>
1976            *
1977            * @param groupId the group id to search with
1978            * @param userId the user id to search with
1979            * @param status the status to search with
1980            * @param start the lower bound of the range of blogs entries to return
1981            * @param end the upper bound of the range of blogs entries to return (not inclusive)
1982            * @param orderByComparator the comparator to order the results by
1983            * @return the ordered range of matching blogs entries
1984            * @throws SystemException if a system exception occurred
1985            */
1986            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_S(
1987                    long groupId, long userId, int status, int start, int end,
1988                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
1989                    throws com.liferay.portal.kernel.exception.SystemException {
1990                    return getPersistence()
1991                                       .findByG_U_S(groupId, userId, status, start, end,
1992                            orderByComparator);
1993            }
1994    
1995            /**
1996            * Finds the first blogs entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
1997            *
1998            * <p>
1999            * 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.
2000            * </p>
2001            *
2002            * @param groupId the group id to search with
2003            * @param userId the user id to search with
2004            * @param status the status to search with
2005            * @param orderByComparator the comparator to order the set by
2006            * @return the first matching blogs entry
2007            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
2008            * @throws SystemException if a system exception occurred
2009            */
2010            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_U_S_First(
2011                    long groupId, long userId, int status,
2012                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2013                    throws com.liferay.portal.kernel.exception.SystemException,
2014                            com.liferay.portlet.blogs.NoSuchEntryException {
2015                    return getPersistence()
2016                                       .findByG_U_S_First(groupId, userId, status, orderByComparator);
2017            }
2018    
2019            /**
2020            * Finds the last blogs entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
2021            *
2022            * <p>
2023            * 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.
2024            * </p>
2025            *
2026            * @param groupId the group id to search with
2027            * @param userId the user id to search with
2028            * @param status the status to search with
2029            * @param orderByComparator the comparator to order the set by
2030            * @return the last matching blogs entry
2031            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
2032            * @throws SystemException if a system exception occurred
2033            */
2034            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_U_S_Last(
2035                    long groupId, long userId, int status,
2036                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2037                    throws com.liferay.portal.kernel.exception.SystemException,
2038                            com.liferay.portlet.blogs.NoSuchEntryException {
2039                    return getPersistence()
2040                                       .findByG_U_S_Last(groupId, userId, status, orderByComparator);
2041            }
2042    
2043            /**
2044            * Finds the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63; and userId = &#63; and status = &#63;.
2045            *
2046            * <p>
2047            * 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.
2048            * </p>
2049            *
2050            * @param entryId the primary key of the current blogs entry
2051            * @param groupId the group id to search with
2052            * @param userId the user id to search with
2053            * @param status the status to search with
2054            * @param orderByComparator the comparator to order the set by
2055            * @return the previous, current, and next blogs entry
2056            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
2057            * @throws SystemException if a system exception occurred
2058            */
2059            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByG_U_S_PrevAndNext(
2060                    long entryId, long groupId, long userId, int status,
2061                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2062                    throws com.liferay.portal.kernel.exception.SystemException,
2063                            com.liferay.portlet.blogs.NoSuchEntryException {
2064                    return getPersistence()
2065                                       .findByG_U_S_PrevAndNext(entryId, groupId, userId, status,
2066                            orderByComparator);
2067            }
2068    
2069            /**
2070            * Filters by the user's permissions and finds all the blogs entries where groupId = &#63; and userId = &#63; and status = &#63;.
2071            *
2072            * @param groupId the group id to search with
2073            * @param userId the user id to search with
2074            * @param status the status to search with
2075            * @return the matching blogs entries that the user has permission to view
2076            * @throws SystemException if a system exception occurred
2077            */
2078            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_S(
2079                    long groupId, long userId, int status)
2080                    throws com.liferay.portal.kernel.exception.SystemException {
2081                    return getPersistence().filterFindByG_U_S(groupId, userId, status);
2082            }
2083    
2084            /**
2085            * Filters by the user's permissions and finds a range of all the blogs entries where groupId = &#63; and userId = &#63; and status = &#63;.
2086            *
2087            * <p>
2088            * 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.
2089            * </p>
2090            *
2091            * @param groupId the group id to search with
2092            * @param userId the user id to search with
2093            * @param status the status to search with
2094            * @param start the lower bound of the range of blogs entries to return
2095            * @param end the upper bound of the range of blogs entries to return (not inclusive)
2096            * @return the range of matching blogs entries that the user has permission to view
2097            * @throws SystemException if a system exception occurred
2098            */
2099            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_S(
2100                    long groupId, long userId, int status, int start, int end)
2101                    throws com.liferay.portal.kernel.exception.SystemException {
2102                    return getPersistence()
2103                                       .filterFindByG_U_S(groupId, userId, status, start, end);
2104            }
2105    
2106            /**
2107            * Filters by the user's permissions and finds an ordered range of all the blogs entries where groupId = &#63; and userId = &#63; and status = &#63;.
2108            *
2109            * <p>
2110            * 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.
2111            * </p>
2112            *
2113            * @param groupId the group id to search with
2114            * @param userId the user id to search with
2115            * @param status the status to search with
2116            * @param start the lower bound of the range of blogs entries to return
2117            * @param end the upper bound of the range of blogs entries to return (not inclusive)
2118            * @param orderByComparator the comparator to order the results by
2119            * @return the ordered range of matching blogs entries that the user has permission to view
2120            * @throws SystemException if a system exception occurred
2121            */
2122            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_S(
2123                    long groupId, long userId, int status, int start, int end,
2124                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2125                    throws com.liferay.portal.kernel.exception.SystemException {
2126                    return getPersistence()
2127                                       .filterFindByG_U_S(groupId, userId, status, start, end,
2128                            orderByComparator);
2129            }
2130    
2131            /**
2132            * Finds all the blogs entries where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
2133            *
2134            * @param groupId the group id to search with
2135            * @param displayDate the display date to search with
2136            * @param status the status to search with
2137            * @return the matching blogs entries
2138            * @throws SystemException if a system exception occurred
2139            */
2140            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_LtD_S(
2141                    long groupId, java.util.Date displayDate, int status)
2142                    throws com.liferay.portal.kernel.exception.SystemException {
2143                    return getPersistence().findByG_LtD_S(groupId, displayDate, status);
2144            }
2145    
2146            /**
2147            * Finds a range of all the blogs entries where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
2148            *
2149            * <p>
2150            * 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.
2151            * </p>
2152            *
2153            * @param groupId the group id to search with
2154            * @param displayDate the display date to search with
2155            * @param status the status to search with
2156            * @param start the lower bound of the range of blogs entries to return
2157            * @param end the upper bound of the range of blogs entries to return (not inclusive)
2158            * @return the range of matching blogs entries
2159            * @throws SystemException if a system exception occurred
2160            */
2161            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_LtD_S(
2162                    long groupId, java.util.Date displayDate, int status, int start, int end)
2163                    throws com.liferay.portal.kernel.exception.SystemException {
2164                    return getPersistence()
2165                                       .findByG_LtD_S(groupId, displayDate, status, start, end);
2166            }
2167    
2168            /**
2169            * Finds an ordered range of all the blogs entries where groupId = &#63; and displayDate &lt; &#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 to search with
2176            * @param displayDate the display date to search with
2177            * @param status the status to search with
2178            * @param start the lower bound of the range of blogs entries to return
2179            * @param end the upper bound of the range of blogs entries to return (not inclusive)
2180            * @param orderByComparator the comparator to order the results by
2181            * @return the ordered range of matching blogs entries
2182            * @throws SystemException if a system exception occurred
2183            */
2184            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_LtD_S(
2185                    long groupId, java.util.Date displayDate, int status, int start,
2186                    int end,
2187                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2188                    throws com.liferay.portal.kernel.exception.SystemException {
2189                    return getPersistence()
2190                                       .findByG_LtD_S(groupId, displayDate, status, start, end,
2191                            orderByComparator);
2192            }
2193    
2194            /**
2195            * Finds the first blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
2196            *
2197            * <p>
2198            * 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.
2199            * </p>
2200            *
2201            * @param groupId the group id to search with
2202            * @param displayDate the display date to search with
2203            * @param status the status to search with
2204            * @param orderByComparator the comparator to order the set by
2205            * @return the first matching blogs entry
2206            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
2207            * @throws SystemException if a system exception occurred
2208            */
2209            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_LtD_S_First(
2210                    long groupId, java.util.Date displayDate, int status,
2211                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2212                    throws com.liferay.portal.kernel.exception.SystemException,
2213                            com.liferay.portlet.blogs.NoSuchEntryException {
2214                    return getPersistence()
2215                                       .findByG_LtD_S_First(groupId, displayDate, status,
2216                            orderByComparator);
2217            }
2218    
2219            /**
2220            * Finds the last blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
2221            *
2222            * <p>
2223            * 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.
2224            * </p>
2225            *
2226            * @param groupId the group id to search with
2227            * @param displayDate the display date to search with
2228            * @param status the status to search with
2229            * @param orderByComparator the comparator to order the set by
2230            * @return the last matching blogs entry
2231            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
2232            * @throws SystemException if a system exception occurred
2233            */
2234            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_LtD_S_Last(
2235                    long groupId, java.util.Date displayDate, int status,
2236                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2237                    throws com.liferay.portal.kernel.exception.SystemException,
2238                            com.liferay.portlet.blogs.NoSuchEntryException {
2239                    return getPersistence()
2240                                       .findByG_LtD_S_Last(groupId, displayDate, status,
2241                            orderByComparator);
2242            }
2243    
2244            /**
2245            * Finds the blogs entries before and after the current blogs entry in the ordered set where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
2246            *
2247            * <p>
2248            * 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.
2249            * </p>
2250            *
2251            * @param entryId the primary key of the current blogs entry
2252            * @param groupId the group id to search with
2253            * @param displayDate the display date to search with
2254            * @param status the status to search with
2255            * @param orderByComparator the comparator to order the set by
2256            * @return the previous, current, and next blogs entry
2257            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
2258            * @throws SystemException if a system exception occurred
2259            */
2260            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByG_LtD_S_PrevAndNext(
2261                    long entryId, long groupId, java.util.Date displayDate, int status,
2262                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2263                    throws com.liferay.portal.kernel.exception.SystemException,
2264                            com.liferay.portlet.blogs.NoSuchEntryException {
2265                    return getPersistence()
2266                                       .findByG_LtD_S_PrevAndNext(entryId, groupId, displayDate,
2267                            status, orderByComparator);
2268            }
2269    
2270            /**
2271            * Filters by the user's permissions and finds all the blogs entries where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
2272            *
2273            * @param groupId the group id to search with
2274            * @param displayDate the display date to search with
2275            * @param status the status to search with
2276            * @return the matching blogs entries that the user has permission to view
2277            * @throws SystemException if a system exception occurred
2278            */
2279            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_LtD_S(
2280                    long groupId, java.util.Date displayDate, int status)
2281                    throws com.liferay.portal.kernel.exception.SystemException {
2282                    return getPersistence().filterFindByG_LtD_S(groupId, displayDate, status);
2283            }
2284    
2285            /**
2286            * Filters by the user's permissions and finds a range of all the blogs entries where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
2287            *
2288            * <p>
2289            * 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.
2290            * </p>
2291            *
2292            * @param groupId the group id to search with
2293            * @param displayDate the display date to search with
2294            * @param status the status to search with
2295            * @param start the lower bound of the range of blogs entries to return
2296            * @param end the upper bound of the range of blogs entries to return (not inclusive)
2297            * @return the range of matching blogs entries that the user has permission to view
2298            * @throws SystemException if a system exception occurred
2299            */
2300            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_LtD_S(
2301                    long groupId, java.util.Date displayDate, int status, int start, int end)
2302                    throws com.liferay.portal.kernel.exception.SystemException {
2303                    return getPersistence()
2304                                       .filterFindByG_LtD_S(groupId, displayDate, status, start, end);
2305            }
2306    
2307            /**
2308            * Filters by the user's permissions and finds an ordered range of all the blogs entries where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
2309            *
2310            * <p>
2311            * 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.
2312            * </p>
2313            *
2314            * @param groupId the group id to search with
2315            * @param displayDate the display date to search with
2316            * @param status the status to search with
2317            * @param start the lower bound of the range of blogs entries to return
2318            * @param end the upper bound of the range of blogs entries to return (not inclusive)
2319            * @param orderByComparator the comparator to order the results by
2320            * @return the ordered range of matching blogs entries that the user has permission to view
2321            * @throws SystemException if a system exception occurred
2322            */
2323            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_LtD_S(
2324                    long groupId, java.util.Date displayDate, int status, int start,
2325                    int end,
2326                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2327                    throws com.liferay.portal.kernel.exception.SystemException {
2328                    return getPersistence()
2329                                       .filterFindByG_LtD_S(groupId, displayDate, status, start,
2330                            end, orderByComparator);
2331            }
2332    
2333            /**
2334            * Finds all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
2335            *
2336            * @param groupId the group id to search with
2337            * @param userId the user id to search with
2338            * @param displayDate the display date to search with
2339            * @param status the status to search with
2340            * @return the matching blogs entries
2341            * @throws SystemException if a system exception occurred
2342            */
2343            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_LtD_S(
2344                    long groupId, long userId, java.util.Date displayDate, int status)
2345                    throws com.liferay.portal.kernel.exception.SystemException {
2346                    return getPersistence()
2347                                       .findByG_U_LtD_S(groupId, userId, displayDate, status);
2348            }
2349    
2350            /**
2351            * Finds a range of all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
2352            *
2353            * <p>
2354            * 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.
2355            * </p>
2356            *
2357            * @param groupId the group id to search with
2358            * @param userId the user id to search with
2359            * @param displayDate the display date to search with
2360            * @param status the status to search with
2361            * @param start the lower bound of the range of blogs entries to return
2362            * @param end the upper bound of the range of blogs entries to return (not inclusive)
2363            * @return the range of matching blogs entries
2364            * @throws SystemException if a system exception occurred
2365            */
2366            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_LtD_S(
2367                    long groupId, long userId, java.util.Date displayDate, int status,
2368                    int start, int end)
2369                    throws com.liferay.portal.kernel.exception.SystemException {
2370                    return getPersistence()
2371                                       .findByG_U_LtD_S(groupId, userId, displayDate, status,
2372                            start, end);
2373            }
2374    
2375            /**
2376            * Finds an ordered range of all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
2377            *
2378            * <p>
2379            * 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.
2380            * </p>
2381            *
2382            * @param groupId the group id to search with
2383            * @param userId the user id to search with
2384            * @param displayDate the display date to search with
2385            * @param status the status to search with
2386            * @param start the lower bound of the range of blogs entries to return
2387            * @param end the upper bound of the range of blogs entries to return (not inclusive)
2388            * @param orderByComparator the comparator to order the results by
2389            * @return the ordered range of matching blogs entries
2390            * @throws SystemException if a system exception occurred
2391            */
2392            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findByG_U_LtD_S(
2393                    long groupId, long userId, java.util.Date displayDate, int status,
2394                    int start, int end,
2395                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2396                    throws com.liferay.portal.kernel.exception.SystemException {
2397                    return getPersistence()
2398                                       .findByG_U_LtD_S(groupId, userId, displayDate, status,
2399                            start, end, orderByComparator);
2400            }
2401    
2402            /**
2403            * Finds the first blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
2404            *
2405            * <p>
2406            * 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.
2407            * </p>
2408            *
2409            * @param groupId the group id to search with
2410            * @param userId the user id to search with
2411            * @param displayDate the display date to search with
2412            * @param status the status to search with
2413            * @param orderByComparator the comparator to order the set by
2414            * @return the first matching blogs entry
2415            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
2416            * @throws SystemException if a system exception occurred
2417            */
2418            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_U_LtD_S_First(
2419                    long groupId, long userId, java.util.Date displayDate, int status,
2420                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2421                    throws com.liferay.portal.kernel.exception.SystemException,
2422                            com.liferay.portlet.blogs.NoSuchEntryException {
2423                    return getPersistence()
2424                                       .findByG_U_LtD_S_First(groupId, userId, displayDate, status,
2425                            orderByComparator);
2426            }
2427    
2428            /**
2429            * Finds the last blogs entry in the ordered set where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
2430            *
2431            * <p>
2432            * 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.
2433            * </p>
2434            *
2435            * @param groupId the group id to search with
2436            * @param userId the user id to search with
2437            * @param displayDate the display date to search with
2438            * @param status the status to search with
2439            * @param orderByComparator the comparator to order the set by
2440            * @return the last matching blogs entry
2441            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a matching blogs entry could not be found
2442            * @throws SystemException if a system exception occurred
2443            */
2444            public static com.liferay.portlet.blogs.model.BlogsEntry findByG_U_LtD_S_Last(
2445                    long groupId, long userId, java.util.Date displayDate, int status,
2446                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2447                    throws com.liferay.portal.kernel.exception.SystemException,
2448                            com.liferay.portlet.blogs.NoSuchEntryException {
2449                    return getPersistence()
2450                                       .findByG_U_LtD_S_Last(groupId, userId, displayDate, status,
2451                            orderByComparator);
2452            }
2453    
2454            /**
2455            * Finds 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;.
2456            *
2457            * <p>
2458            * 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.
2459            * </p>
2460            *
2461            * @param entryId the primary key of the current blogs entry
2462            * @param groupId the group id to search with
2463            * @param userId the user id to search with
2464            * @param displayDate the display date to search with
2465            * @param status the status to search with
2466            * @param orderByComparator the comparator to order the set by
2467            * @return the previous, current, and next blogs entry
2468            * @throws com.liferay.portlet.blogs.NoSuchEntryException if a blogs entry with the primary key could not be found
2469            * @throws SystemException if a system exception occurred
2470            */
2471            public static com.liferay.portlet.blogs.model.BlogsEntry[] findByG_U_LtD_S_PrevAndNext(
2472                    long entryId, long groupId, long userId, java.util.Date displayDate,
2473                    int status,
2474                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2475                    throws com.liferay.portal.kernel.exception.SystemException,
2476                            com.liferay.portlet.blogs.NoSuchEntryException {
2477                    return getPersistence()
2478                                       .findByG_U_LtD_S_PrevAndNext(entryId, groupId, userId,
2479                            displayDate, status, orderByComparator);
2480            }
2481    
2482            /**
2483            * Filters by the user's permissions and finds all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
2484            *
2485            * @param groupId the group id to search with
2486            * @param userId the user id to search with
2487            * @param displayDate the display date to search with
2488            * @param status the status to search with
2489            * @return the matching blogs entries that the user has permission to view
2490            * @throws SystemException if a system exception occurred
2491            */
2492            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_LtD_S(
2493                    long groupId, long userId, java.util.Date displayDate, int status)
2494                    throws com.liferay.portal.kernel.exception.SystemException {
2495                    return getPersistence()
2496                                       .filterFindByG_U_LtD_S(groupId, userId, displayDate, status);
2497            }
2498    
2499            /**
2500            * Filters by the user's permissions and finds a range of all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
2501            *
2502            * <p>
2503            * 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.
2504            * </p>
2505            *
2506            * @param groupId the group id to search with
2507            * @param userId the user id to search with
2508            * @param displayDate the display date to search with
2509            * @param status the status to search with
2510            * @param start the lower bound of the range of blogs entries to return
2511            * @param end the upper bound of the range of blogs entries to return (not inclusive)
2512            * @return the range of matching blogs entries that the user has permission to view
2513            * @throws SystemException if a system exception occurred
2514            */
2515            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_LtD_S(
2516                    long groupId, long userId, java.util.Date displayDate, int status,
2517                    int start, int end)
2518                    throws com.liferay.portal.kernel.exception.SystemException {
2519                    return getPersistence()
2520                                       .filterFindByG_U_LtD_S(groupId, userId, displayDate, status,
2521                            start, end);
2522            }
2523    
2524            /**
2525            * Filters by the user's permissions and finds an ordered range of all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
2526            *
2527            * <p>
2528            * 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.
2529            * </p>
2530            *
2531            * @param groupId the group id to search with
2532            * @param userId the user id to search with
2533            * @param displayDate the display date to search with
2534            * @param status the status to search with
2535            * @param start the lower bound of the range of blogs entries to return
2536            * @param end the upper bound of the range of blogs entries to return (not inclusive)
2537            * @param orderByComparator the comparator to order the results by
2538            * @return the ordered range of matching blogs entries that the user has permission to view
2539            * @throws SystemException if a system exception occurred
2540            */
2541            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> filterFindByG_U_LtD_S(
2542                    long groupId, long userId, java.util.Date displayDate, int status,
2543                    int start, int end,
2544                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2545                    throws com.liferay.portal.kernel.exception.SystemException {
2546                    return getPersistence()
2547                                       .filterFindByG_U_LtD_S(groupId, userId, displayDate, status,
2548                            start, end, orderByComparator);
2549            }
2550    
2551            /**
2552            * Finds all the blogs entries.
2553            *
2554            * @return the blogs entries
2555            * @throws SystemException if a system exception occurred
2556            */
2557            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findAll()
2558                    throws com.liferay.portal.kernel.exception.SystemException {
2559                    return getPersistence().findAll();
2560            }
2561    
2562            /**
2563            * Finds a range of all the blogs entries.
2564            *
2565            * <p>
2566            * 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.
2567            * </p>
2568            *
2569            * @param start the lower bound of the range of blogs entries to return
2570            * @param end the upper bound of the range of blogs entries to return (not inclusive)
2571            * @return the range of blogs entries
2572            * @throws SystemException if a system exception occurred
2573            */
2574            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findAll(
2575                    int start, int end)
2576                    throws com.liferay.portal.kernel.exception.SystemException {
2577                    return getPersistence().findAll(start, end);
2578            }
2579    
2580            /**
2581            * Finds an ordered range of all the blogs entries.
2582            *
2583            * <p>
2584            * 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.
2585            * </p>
2586            *
2587            * @param start the lower bound of the range of blogs entries to return
2588            * @param end the upper bound of the range of blogs entries to return (not inclusive)
2589            * @param orderByComparator the comparator to order the results by
2590            * @return the ordered range of blogs entries
2591            * @throws SystemException if a system exception occurred
2592            */
2593            public static java.util.List<com.liferay.portlet.blogs.model.BlogsEntry> findAll(
2594                    int start, int end,
2595                    com.liferay.portal.kernel.util.OrderByComparator orderByComparator)
2596                    throws com.liferay.portal.kernel.exception.SystemException {
2597                    return getPersistence().findAll(start, end, orderByComparator);
2598            }
2599    
2600            /**
2601            * Removes all the blogs entries where uuid = &#63; from the database.
2602            *
2603            * @param uuid the uuid to search with
2604            * @throws SystemException if a system exception occurred
2605            */
2606            public static void removeByUuid(java.lang.String uuid)
2607                    throws com.liferay.portal.kernel.exception.SystemException {
2608                    getPersistence().removeByUuid(uuid);
2609            }
2610    
2611            /**
2612            * Removes the blogs entry where uuid = &#63; and groupId = &#63; from the database.
2613            *
2614            * @param uuid the uuid to search with
2615            * @param groupId the group id to search with
2616            * @throws SystemException if a system exception occurred
2617            */
2618            public static void removeByUUID_G(java.lang.String uuid, long groupId)
2619                    throws com.liferay.portal.kernel.exception.SystemException,
2620                            com.liferay.portlet.blogs.NoSuchEntryException {
2621                    getPersistence().removeByUUID_G(uuid, groupId);
2622            }
2623    
2624            /**
2625            * Removes all the blogs entries where groupId = &#63; from the database.
2626            *
2627            * @param groupId the group id to search with
2628            * @throws SystemException if a system exception occurred
2629            */
2630            public static void removeByGroupId(long groupId)
2631                    throws com.liferay.portal.kernel.exception.SystemException {
2632                    getPersistence().removeByGroupId(groupId);
2633            }
2634    
2635            /**
2636            * Removes all the blogs entries where companyId = &#63; from the database.
2637            *
2638            * @param companyId the company id to search with
2639            * @throws SystemException if a system exception occurred
2640            */
2641            public static void removeByCompanyId(long companyId)
2642                    throws com.liferay.portal.kernel.exception.SystemException {
2643                    getPersistence().removeByCompanyId(companyId);
2644            }
2645    
2646            /**
2647            * Removes all the blogs entries where companyId = &#63; and userId = &#63; from the database.
2648            *
2649            * @param companyId the company id to search with
2650            * @param userId the user id to search with
2651            * @throws SystemException if a system exception occurred
2652            */
2653            public static void removeByC_U(long companyId, long userId)
2654                    throws com.liferay.portal.kernel.exception.SystemException {
2655                    getPersistence().removeByC_U(companyId, userId);
2656            }
2657    
2658            /**
2659            * Removes all the blogs entries where companyId = &#63; and displayDate &lt; &#63; from the database.
2660            *
2661            * @param companyId the company id to search with
2662            * @param displayDate the display date to search with
2663            * @throws SystemException if a system exception occurred
2664            */
2665            public static void removeByC_LtD(long companyId, java.util.Date displayDate)
2666                    throws com.liferay.portal.kernel.exception.SystemException {
2667                    getPersistence().removeByC_LtD(companyId, displayDate);
2668            }
2669    
2670            /**
2671            * Removes all the blogs entries where companyId = &#63; and status = &#63; from the database.
2672            *
2673            * @param companyId the company id to search with
2674            * @param status the status to search with
2675            * @throws SystemException if a system exception occurred
2676            */
2677            public static void removeByC_S(long companyId, int status)
2678                    throws com.liferay.portal.kernel.exception.SystemException {
2679                    getPersistence().removeByC_S(companyId, status);
2680            }
2681    
2682            /**
2683            * Removes the blogs entry where groupId = &#63; and urlTitle = &#63; from the database.
2684            *
2685            * @param groupId the group id to search with
2686            * @param urlTitle the url title to search with
2687            * @throws SystemException if a system exception occurred
2688            */
2689            public static void removeByG_UT(long groupId, java.lang.String urlTitle)
2690                    throws com.liferay.portal.kernel.exception.SystemException,
2691                            com.liferay.portlet.blogs.NoSuchEntryException {
2692                    getPersistence().removeByG_UT(groupId, urlTitle);
2693            }
2694    
2695            /**
2696            * Removes all the blogs entries where groupId = &#63; and displayDate &lt; &#63; from the database.
2697            *
2698            * @param groupId the group id to search with
2699            * @param displayDate the display date to search with
2700            * @throws SystemException if a system exception occurred
2701            */
2702            public static void removeByG_LtD(long groupId, java.util.Date displayDate)
2703                    throws com.liferay.portal.kernel.exception.SystemException {
2704                    getPersistence().removeByG_LtD(groupId, displayDate);
2705            }
2706    
2707            /**
2708            * Removes all the blogs entries where groupId = &#63; and status = &#63; from the database.
2709            *
2710            * @param groupId the group id to search with
2711            * @param status the status to search with
2712            * @throws SystemException if a system exception occurred
2713            */
2714            public static void removeByG_S(long groupId, int status)
2715                    throws com.liferay.portal.kernel.exception.SystemException {
2716                    getPersistence().removeByG_S(groupId, status);
2717            }
2718    
2719            /**
2720            * Removes all the blogs entries where companyId = &#63; and userId = &#63; and status = &#63; from the database.
2721            *
2722            * @param companyId the company id to search with
2723            * @param userId the user id to search with
2724            * @param status the status to search with
2725            * @throws SystemException if a system exception occurred
2726            */
2727            public static void removeByC_U_S(long companyId, long userId, int status)
2728                    throws com.liferay.portal.kernel.exception.SystemException {
2729                    getPersistence().removeByC_U_S(companyId, userId, status);
2730            }
2731    
2732            /**
2733            * Removes all the blogs entries where companyId = &#63; and displayDate &lt; &#63; and status = &#63; from the database.
2734            *
2735            * @param companyId the company id to search with
2736            * @param displayDate the display date to search with
2737            * @param status the status to search with
2738            * @throws SystemException if a system exception occurred
2739            */
2740            public static void removeByC_LtD_S(long companyId,
2741                    java.util.Date displayDate, int status)
2742                    throws com.liferay.portal.kernel.exception.SystemException {
2743                    getPersistence().removeByC_LtD_S(companyId, displayDate, status);
2744            }
2745    
2746            /**
2747            * Removes all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; from the database.
2748            *
2749            * @param groupId the group id to search with
2750            * @param userId the user id to search with
2751            * @param displayDate the display date to search with
2752            * @throws SystemException if a system exception occurred
2753            */
2754            public static void removeByG_U_LtD(long groupId, long userId,
2755                    java.util.Date displayDate)
2756                    throws com.liferay.portal.kernel.exception.SystemException {
2757                    getPersistence().removeByG_U_LtD(groupId, userId, displayDate);
2758            }
2759    
2760            /**
2761            * Removes all the blogs entries where groupId = &#63; and userId = &#63; and status = &#63; from the database.
2762            *
2763            * @param groupId the group id to search with
2764            * @param userId the user id to search with
2765            * @param status the status to search with
2766            * @throws SystemException if a system exception occurred
2767            */
2768            public static void removeByG_U_S(long groupId, long userId, int status)
2769                    throws com.liferay.portal.kernel.exception.SystemException {
2770                    getPersistence().removeByG_U_S(groupId, userId, status);
2771            }
2772    
2773            /**
2774            * Removes all the blogs entries where groupId = &#63; and displayDate &lt; &#63; and status = &#63; from the database.
2775            *
2776            * @param groupId the group id to search with
2777            * @param displayDate the display date to search with
2778            * @param status the status to search with
2779            * @throws SystemException if a system exception occurred
2780            */
2781            public static void removeByG_LtD_S(long groupId,
2782                    java.util.Date displayDate, int status)
2783                    throws com.liferay.portal.kernel.exception.SystemException {
2784                    getPersistence().removeByG_LtD_S(groupId, displayDate, status);
2785            }
2786    
2787            /**
2788            * Removes all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63; from the database.
2789            *
2790            * @param groupId the group id to search with
2791            * @param userId the user id to search with
2792            * @param displayDate the display date to search with
2793            * @param status the status to search with
2794            * @throws SystemException if a system exception occurred
2795            */
2796            public static void removeByG_U_LtD_S(long groupId, long userId,
2797                    java.util.Date displayDate, int status)
2798                    throws com.liferay.portal.kernel.exception.SystemException {
2799                    getPersistence().removeByG_U_LtD_S(groupId, userId, displayDate, status);
2800            }
2801    
2802            /**
2803            * Removes all the blogs entries from the database.
2804            *
2805            * @throws SystemException if a system exception occurred
2806            */
2807            public static void removeAll()
2808                    throws com.liferay.portal.kernel.exception.SystemException {
2809                    getPersistence().removeAll();
2810            }
2811    
2812            /**
2813            * Counts all the blogs entries where uuid = &#63;.
2814            *
2815            * @param uuid the uuid to search with
2816            * @return the number of matching blogs entries
2817            * @throws SystemException if a system exception occurred
2818            */
2819            public static int countByUuid(java.lang.String uuid)
2820                    throws com.liferay.portal.kernel.exception.SystemException {
2821                    return getPersistence().countByUuid(uuid);
2822            }
2823    
2824            /**
2825            * Counts all the blogs entries where uuid = &#63; and groupId = &#63;.
2826            *
2827            * @param uuid the uuid to search with
2828            * @param groupId the group id to search with
2829            * @return the number of matching blogs entries
2830            * @throws SystemException if a system exception occurred
2831            */
2832            public static int countByUUID_G(java.lang.String uuid, long groupId)
2833                    throws com.liferay.portal.kernel.exception.SystemException {
2834                    return getPersistence().countByUUID_G(uuid, groupId);
2835            }
2836    
2837            /**
2838            * Counts all the blogs entries where groupId = &#63;.
2839            *
2840            * @param groupId the group id to search with
2841            * @return the number of matching blogs entries
2842            * @throws SystemException if a system exception occurred
2843            */
2844            public static int countByGroupId(long groupId)
2845                    throws com.liferay.portal.kernel.exception.SystemException {
2846                    return getPersistence().countByGroupId(groupId);
2847            }
2848    
2849            /**
2850            * Filters by the user's permissions and counts all the blogs entries where groupId = &#63;.
2851            *
2852            * @param groupId the group id to search with
2853            * @return the number of matching blogs entries that the user has permission to view
2854            * @throws SystemException if a system exception occurred
2855            */
2856            public static int filterCountByGroupId(long groupId)
2857                    throws com.liferay.portal.kernel.exception.SystemException {
2858                    return getPersistence().filterCountByGroupId(groupId);
2859            }
2860    
2861            /**
2862            * Counts all the blogs entries where companyId = &#63;.
2863            *
2864            * @param companyId the company id to search with
2865            * @return the number of matching blogs entries
2866            * @throws SystemException if a system exception occurred
2867            */
2868            public static int countByCompanyId(long companyId)
2869                    throws com.liferay.portal.kernel.exception.SystemException {
2870                    return getPersistence().countByCompanyId(companyId);
2871            }
2872    
2873            /**
2874            * Counts all the blogs entries where companyId = &#63; and userId = &#63;.
2875            *
2876            * @param companyId the company id to search with
2877            * @param userId the user id to search with
2878            * @return the number of matching blogs entries
2879            * @throws SystemException if a system exception occurred
2880            */
2881            public static int countByC_U(long companyId, long userId)
2882                    throws com.liferay.portal.kernel.exception.SystemException {
2883                    return getPersistence().countByC_U(companyId, userId);
2884            }
2885    
2886            /**
2887            * Counts all the blogs entries where companyId = &#63; and displayDate &lt; &#63;.
2888            *
2889            * @param companyId the company id to search with
2890            * @param displayDate the display date to search with
2891            * @return the number of matching blogs entries
2892            * @throws SystemException if a system exception occurred
2893            */
2894            public static int countByC_LtD(long companyId, java.util.Date displayDate)
2895                    throws com.liferay.portal.kernel.exception.SystemException {
2896                    return getPersistence().countByC_LtD(companyId, displayDate);
2897            }
2898    
2899            /**
2900            * Counts all the blogs entries where companyId = &#63; and status = &#63;.
2901            *
2902            * @param companyId the company id to search with
2903            * @param status the status to search with
2904            * @return the number of matching blogs entries
2905            * @throws SystemException if a system exception occurred
2906            */
2907            public static int countByC_S(long companyId, int status)
2908                    throws com.liferay.portal.kernel.exception.SystemException {
2909                    return getPersistence().countByC_S(companyId, status);
2910            }
2911    
2912            /**
2913            * Counts all the blogs entries where groupId = &#63; and urlTitle = &#63;.
2914            *
2915            * @param groupId the group id to search with
2916            * @param urlTitle the url title to search with
2917            * @return the number of matching blogs entries
2918            * @throws SystemException if a system exception occurred
2919            */
2920            public static int countByG_UT(long groupId, java.lang.String urlTitle)
2921                    throws com.liferay.portal.kernel.exception.SystemException {
2922                    return getPersistence().countByG_UT(groupId, urlTitle);
2923            }
2924    
2925            /**
2926            * Filters by the user's permissions and counts all the blogs entries where groupId = &#63; and urlTitle = &#63;.
2927            *
2928            * @param groupId the group id to search with
2929            * @param urlTitle the url title to search with
2930            * @return the number of matching blogs entries that the user has permission to view
2931            * @throws SystemException if a system exception occurred
2932            */
2933            public static int filterCountByG_UT(long groupId, java.lang.String urlTitle)
2934                    throws com.liferay.portal.kernel.exception.SystemException {
2935                    return getPersistence().filterCountByG_UT(groupId, urlTitle);
2936            }
2937    
2938            /**
2939            * Counts all the blogs entries where groupId = &#63; and displayDate &lt; &#63;.
2940            *
2941            * @param groupId the group id to search with
2942            * @param displayDate the display date to search with
2943            * @return the number of matching blogs entries
2944            * @throws SystemException if a system exception occurred
2945            */
2946            public static int countByG_LtD(long groupId, java.util.Date displayDate)
2947                    throws com.liferay.portal.kernel.exception.SystemException {
2948                    return getPersistence().countByG_LtD(groupId, displayDate);
2949            }
2950    
2951            /**
2952            * Filters by the user's permissions and counts all the blogs entries where groupId = &#63; and displayDate &lt; &#63;.
2953            *
2954            * @param groupId the group id to search with
2955            * @param displayDate the display date to search with
2956            * @return the number of matching blogs entries that the user has permission to view
2957            * @throws SystemException if a system exception occurred
2958            */
2959            public static int filterCountByG_LtD(long groupId,
2960                    java.util.Date displayDate)
2961                    throws com.liferay.portal.kernel.exception.SystemException {
2962                    return getPersistence().filterCountByG_LtD(groupId, displayDate);
2963            }
2964    
2965            /**
2966            * Counts all the blogs entries where groupId = &#63; and status = &#63;.
2967            *
2968            * @param groupId the group id to search with
2969            * @param status the status to search with
2970            * @return the number of matching blogs entries
2971            * @throws SystemException if a system exception occurred
2972            */
2973            public static int countByG_S(long groupId, int status)
2974                    throws com.liferay.portal.kernel.exception.SystemException {
2975                    return getPersistence().countByG_S(groupId, status);
2976            }
2977    
2978            /**
2979            * Filters by the user's permissions and counts all the blogs entries where groupId = &#63; and status = &#63;.
2980            *
2981            * @param groupId the group id to search with
2982            * @param status the status to search with
2983            * @return the number of matching blogs entries that the user has permission to view
2984            * @throws SystemException if a system exception occurred
2985            */
2986            public static int filterCountByG_S(long groupId, int status)
2987                    throws com.liferay.portal.kernel.exception.SystemException {
2988                    return getPersistence().filterCountByG_S(groupId, status);
2989            }
2990    
2991            /**
2992            * Counts all the blogs entries where companyId = &#63; and userId = &#63; and status = &#63;.
2993            *
2994            * @param companyId the company id to search with
2995            * @param userId the user id to search with
2996            * @param status the status to search with
2997            * @return the number of matching blogs entries
2998            * @throws SystemException if a system exception occurred
2999            */
3000            public static int countByC_U_S(long companyId, long userId, int status)
3001                    throws com.liferay.portal.kernel.exception.SystemException {
3002                    return getPersistence().countByC_U_S(companyId, userId, status);
3003            }
3004    
3005            /**
3006            * Counts all the blogs entries where companyId = &#63; and displayDate &lt; &#63; and status = &#63;.
3007            *
3008            * @param companyId the company id to search with
3009            * @param displayDate the display date to search with
3010            * @param status the status to search with
3011            * @return the number of matching blogs entries
3012            * @throws SystemException if a system exception occurred
3013            */
3014            public static int countByC_LtD_S(long companyId,
3015                    java.util.Date displayDate, int status)
3016                    throws com.liferay.portal.kernel.exception.SystemException {
3017                    return getPersistence().countByC_LtD_S(companyId, displayDate, status);
3018            }
3019    
3020            /**
3021            * Counts all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
3022            *
3023            * @param groupId the group id to search with
3024            * @param userId the user id to search with
3025            * @param displayDate the display date to search with
3026            * @return the number of matching blogs entries
3027            * @throws SystemException if a system exception occurred
3028            */
3029            public static int countByG_U_LtD(long groupId, long userId,
3030                    java.util.Date displayDate)
3031                    throws com.liferay.portal.kernel.exception.SystemException {
3032                    return getPersistence().countByG_U_LtD(groupId, userId, displayDate);
3033            }
3034    
3035            /**
3036            * Filters by the user's permissions and counts all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63;.
3037            *
3038            * @param groupId the group id to search with
3039            * @param userId the user id to search with
3040            * @param displayDate the display date to search with
3041            * @return the number of matching blogs entries that the user has permission to view
3042            * @throws SystemException if a system exception occurred
3043            */
3044            public static int filterCountByG_U_LtD(long groupId, long userId,
3045                    java.util.Date displayDate)
3046                    throws com.liferay.portal.kernel.exception.SystemException {
3047                    return getPersistence()
3048                                       .filterCountByG_U_LtD(groupId, userId, displayDate);
3049            }
3050    
3051            /**
3052            * Counts all the blogs entries where groupId = &#63; and userId = &#63; and status = &#63;.
3053            *
3054            * @param groupId the group id to search with
3055            * @param userId the user id to search with
3056            * @param status the status to search with
3057            * @return the number of matching blogs entries
3058            * @throws SystemException if a system exception occurred
3059            */
3060            public static int countByG_U_S(long groupId, long userId, int status)
3061                    throws com.liferay.portal.kernel.exception.SystemException {
3062                    return getPersistence().countByG_U_S(groupId, userId, status);
3063            }
3064    
3065            /**
3066            * Filters by the user's permissions and counts all the blogs entries where groupId = &#63; and userId = &#63; and status = &#63;.
3067            *
3068            * @param groupId the group id to search with
3069            * @param userId the user id to search with
3070            * @param status the status to search with
3071            * @return the number of matching blogs entries that the user has permission to view
3072            * @throws SystemException if a system exception occurred
3073            */
3074            public static int filterCountByG_U_S(long groupId, long userId, int status)
3075                    throws com.liferay.portal.kernel.exception.SystemException {
3076                    return getPersistence().filterCountByG_U_S(groupId, userId, status);
3077            }
3078    
3079            /**
3080            * Counts all the blogs entries where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
3081            *
3082            * @param groupId the group id to search with
3083            * @param displayDate the display date to search with
3084            * @param status the status to search with
3085            * @return the number of matching blogs entries
3086            * @throws SystemException if a system exception occurred
3087            */
3088            public static int countByG_LtD_S(long groupId, java.util.Date displayDate,
3089                    int status) throws com.liferay.portal.kernel.exception.SystemException {
3090                    return getPersistence().countByG_LtD_S(groupId, displayDate, status);
3091            }
3092    
3093            /**
3094            * Filters by the user's permissions and counts all the blogs entries where groupId = &#63; and displayDate &lt; &#63; and status = &#63;.
3095            *
3096            * @param groupId the group id to search with
3097            * @param displayDate the display date to search with
3098            * @param status the status to search with
3099            * @return the number of matching blogs entries that the user has permission to view
3100            * @throws SystemException if a system exception occurred
3101            */
3102            public static int filterCountByG_LtD_S(long groupId,
3103                    java.util.Date displayDate, int status)
3104                    throws com.liferay.portal.kernel.exception.SystemException {
3105                    return getPersistence()
3106                                       .filterCountByG_LtD_S(groupId, displayDate, status);
3107            }
3108    
3109            /**
3110            * Counts all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
3111            *
3112            * @param groupId the group id to search with
3113            * @param userId the user id to search with
3114            * @param displayDate the display date to search with
3115            * @param status the status to search with
3116            * @return the number of matching blogs entries
3117            * @throws SystemException if a system exception occurred
3118            */
3119            public static int countByG_U_LtD_S(long groupId, long userId,
3120                    java.util.Date displayDate, int status)
3121                    throws com.liferay.portal.kernel.exception.SystemException {
3122                    return getPersistence()
3123                                       .countByG_U_LtD_S(groupId, userId, displayDate, status);
3124            }
3125    
3126            /**
3127            * Filters by the user's permissions and counts all the blogs entries where groupId = &#63; and userId = &#63; and displayDate &lt; &#63; and status = &#63;.
3128            *
3129            * @param groupId the group id to search with
3130            * @param userId the user id to search with
3131            * @param displayDate the display date to search with
3132            * @param status the status to search with
3133            * @return the number of matching blogs entries that the user has permission to view
3134            * @throws SystemException if a system exception occurred
3135            */
3136            public static int filterCountByG_U_LtD_S(long groupId, long userId,
3137                    java.util.Date displayDate, int status)
3138                    throws com.liferay.portal.kernel.exception.SystemException {
3139                    return getPersistence()
3140                                       .filterCountByG_U_LtD_S(groupId, userId, displayDate, status);
3141            }
3142    
3143            /**
3144            * Counts all the blogs entries.
3145            *
3146            * @return the number of blogs entries
3147            * @throws SystemException if a system exception occurred
3148            */
3149            public static int countAll()
3150                    throws com.liferay.portal.kernel.exception.SystemException {
3151                    return getPersistence().countAll();
3152            }
3153    
3154            public static BlogsEntryPersistence getPersistence() {
3155                    if (_persistence == null) {
3156                            _persistence = (BlogsEntryPersistence)PortalBeanLocatorUtil.locate(BlogsEntryPersistence.class.getName());
3157                    }
3158    
3159                    return _persistence;
3160            }
3161    
3162            public void setPersistence(BlogsEntryPersistence persistence) {
3163                    _persistence = persistence;
3164            }
3165    
3166            private static BlogsEntryPersistence _persistence;
3167    }