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