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