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