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