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