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