001 /** 002 * Copyright (c) 2000-present 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 aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 020 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 021 import com.liferay.portal.kernel.util.OrderByComparator; 022 import com.liferay.portal.kernel.util.ReferenceRegistry; 023 import com.liferay.portal.service.ServiceContext; 024 025 import com.liferay.portlet.blogs.model.BlogsEntry; 026 027 import java.util.Date; 028 import java.util.List; 029 030 /** 031 * The persistence utility for the blogs entry service. This utility wraps {@link com.liferay.portlet.blogs.service.persistence.impl.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. 032 * 033 * <p> 034 * Caching information and settings can be found in <code>portal.properties</code> 035 * </p> 036 * 037 * @author Brian Wing Shun Chan 038 * @see BlogsEntryPersistence 039 * @see com.liferay.portlet.blogs.service.persistence.impl.BlogsEntryPersistenceImpl 040 * @generated 041 */ 042 @ProviderType 043 public class BlogsEntryUtil { 044 /* 045 * NOTE FOR DEVELOPERS: 046 * 047 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 048 */ 049 050 /** 051 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 052 */ 053 public static void clearCache() { 054 getPersistence().clearCache(); 055 } 056 057 /** 058 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 059 */ 060 public static void clearCache(BlogsEntry blogsEntry) { 061 getPersistence().clearCache(blogsEntry); 062 } 063 064 /** 065 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 066 */ 067 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) { 068 return getPersistence().countWithDynamicQuery(dynamicQuery); 069 } 070 071 /** 072 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 073 */ 074 public static List<BlogsEntry> findWithDynamicQuery( 075 DynamicQuery dynamicQuery) { 076 return getPersistence().findWithDynamicQuery(dynamicQuery); 077 } 078 079 /** 080 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 081 */ 082 public static List<BlogsEntry> findWithDynamicQuery( 083 DynamicQuery dynamicQuery, int start, int end) { 084 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 085 } 086 087 /** 088 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 089 */ 090 public static List<BlogsEntry> findWithDynamicQuery( 091 DynamicQuery dynamicQuery, int start, int end, 092 OrderByComparator<BlogsEntry> orderByComparator) { 093 return getPersistence() 094 .findWithDynamicQuery(dynamicQuery, start, end, 095 orderByComparator); 096 } 097 098 /** 099 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 100 */ 101 public static BlogsEntry update(BlogsEntry blogsEntry) { 102 return getPersistence().update(blogsEntry); 103 } 104 105 /** 106 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 107 */ 108 public static BlogsEntry update(BlogsEntry blogsEntry, 109 ServiceContext serviceContext) { 110 return getPersistence().update(blogsEntry, serviceContext); 111 } 112 113 /** 114 * Returns all the blogs entries where uuid = ?. 115 * 116 * @param uuid the uuid 117 * @return the matching blogs entries 118 */ 119 public static List<BlogsEntry> findByUuid(java.lang.String uuid) { 120 return getPersistence().findByUuid(uuid); 121 } 122 123 /** 124 * Returns a range of all the blogs entries where uuid = ?. 125 * 126 * <p> 127 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 128 * </p> 129 * 130 * @param uuid the uuid 131 * @param start the lower bound of the range of blogs entries 132 * @param end the upper bound of the range of blogs entries (not inclusive) 133 * @return the range of matching blogs entries 134 */ 135 public static List<BlogsEntry> findByUuid(java.lang.String uuid, int start, 136 int end) { 137 return getPersistence().findByUuid(uuid, start, end); 138 } 139 140 /** 141 * Returns an ordered range of all the blogs entries where uuid = ?. 142 * 143 * <p> 144 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 145 * </p> 146 * 147 * @param uuid the uuid 148 * @param start the lower bound of the range of blogs entries 149 * @param end the upper bound of the range of blogs entries (not inclusive) 150 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 151 * @return the ordered range of matching blogs entries 152 */ 153 public static List<BlogsEntry> findByUuid(java.lang.String uuid, int start, 154 int end, OrderByComparator<BlogsEntry> orderByComparator) { 155 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 156 } 157 158 /** 159 * Returns an ordered range of all the blogs entries where uuid = ?. 160 * 161 * <p> 162 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 163 * </p> 164 * 165 * @param uuid the uuid 166 * @param start the lower bound of the range of blogs entries 167 * @param end the upper bound of the range of blogs entries (not inclusive) 168 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 169 * @param retrieveFromCache whether to retrieve from the finder cache 170 * @return the ordered range of matching blogs entries 171 */ 172 public static List<BlogsEntry> findByUuid(java.lang.String uuid, int start, 173 int end, OrderByComparator<BlogsEntry> orderByComparator, 174 boolean retrieveFromCache) { 175 return getPersistence() 176 .findByUuid(uuid, start, end, orderByComparator, 177 retrieveFromCache); 178 } 179 180 /** 181 * Returns the first blogs entry in the ordered set where uuid = ?. 182 * 183 * @param uuid the uuid 184 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 185 * @return the first matching blogs entry 186 * @throws NoSuchEntryException if a matching blogs entry could not be found 187 */ 188 public static BlogsEntry findByUuid_First(java.lang.String uuid, 189 OrderByComparator<BlogsEntry> orderByComparator) 190 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 191 return getPersistence().findByUuid_First(uuid, orderByComparator); 192 } 193 194 /** 195 * Returns the first blogs entry in the ordered set where uuid = ?. 196 * 197 * @param uuid the uuid 198 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 199 * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 200 */ 201 public static BlogsEntry fetchByUuid_First(java.lang.String uuid, 202 OrderByComparator<BlogsEntry> orderByComparator) { 203 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 204 } 205 206 /** 207 * Returns the last blogs entry in the ordered set where uuid = ?. 208 * 209 * @param uuid the uuid 210 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 211 * @return the last matching blogs entry 212 * @throws NoSuchEntryException if a matching blogs entry could not be found 213 */ 214 public static BlogsEntry findByUuid_Last(java.lang.String uuid, 215 OrderByComparator<BlogsEntry> orderByComparator) 216 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 217 return getPersistence().findByUuid_Last(uuid, orderByComparator); 218 } 219 220 /** 221 * Returns the last blogs entry in the ordered set where uuid = ?. 222 * 223 * @param uuid the uuid 224 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 225 * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 226 */ 227 public static BlogsEntry fetchByUuid_Last(java.lang.String uuid, 228 OrderByComparator<BlogsEntry> orderByComparator) { 229 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 230 } 231 232 /** 233 * Returns the blogs entries before and after the current blogs entry in the ordered set where uuid = ?. 234 * 235 * @param entryId the primary key of the current blogs entry 236 * @param uuid the uuid 237 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 238 * @return the previous, current, and next blogs entry 239 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 240 */ 241 public static BlogsEntry[] findByUuid_PrevAndNext(long entryId, 242 java.lang.String uuid, OrderByComparator<BlogsEntry> orderByComparator) 243 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 244 return getPersistence() 245 .findByUuid_PrevAndNext(entryId, uuid, orderByComparator); 246 } 247 248 /** 249 * Removes all the blogs entries where uuid = ? from the database. 250 * 251 * @param uuid the uuid 252 */ 253 public static void removeByUuid(java.lang.String uuid) { 254 getPersistence().removeByUuid(uuid); 255 } 256 257 /** 258 * Returns the number of blogs entries where uuid = ?. 259 * 260 * @param uuid the uuid 261 * @return the number of matching blogs entries 262 */ 263 public static int countByUuid(java.lang.String uuid) { 264 return getPersistence().countByUuid(uuid); 265 } 266 267 /** 268 * Returns the blogs entry where uuid = ? and groupId = ? or throws a {@link NoSuchEntryException} if it could not be found. 269 * 270 * @param uuid the uuid 271 * @param groupId the group ID 272 * @return the matching blogs entry 273 * @throws NoSuchEntryException if a matching blogs entry could not be found 274 */ 275 public static BlogsEntry findByUUID_G(java.lang.String uuid, long groupId) 276 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 277 return getPersistence().findByUUID_G(uuid, groupId); 278 } 279 280 /** 281 * Returns the blogs entry where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 282 * 283 * @param uuid the uuid 284 * @param groupId the group ID 285 * @return the matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 286 */ 287 public static BlogsEntry fetchByUUID_G(java.lang.String uuid, long groupId) { 288 return getPersistence().fetchByUUID_G(uuid, groupId); 289 } 290 291 /** 292 * Returns the blogs entry where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 293 * 294 * @param uuid the uuid 295 * @param groupId the group ID 296 * @param retrieveFromCache whether to retrieve from the finder cache 297 * @return the matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 298 */ 299 public static BlogsEntry fetchByUUID_G(java.lang.String uuid, long groupId, 300 boolean retrieveFromCache) { 301 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 302 } 303 304 /** 305 * Removes the blogs entry where uuid = ? and groupId = ? from the database. 306 * 307 * @param uuid the uuid 308 * @param groupId the group ID 309 * @return the blogs entry that was removed 310 */ 311 public static BlogsEntry removeByUUID_G(java.lang.String uuid, long groupId) 312 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 313 return getPersistence().removeByUUID_G(uuid, groupId); 314 } 315 316 /** 317 * Returns the number of blogs entries where uuid = ? and groupId = ?. 318 * 319 * @param uuid the uuid 320 * @param groupId the group ID 321 * @return the number of matching blogs entries 322 */ 323 public static int countByUUID_G(java.lang.String uuid, long groupId) { 324 return getPersistence().countByUUID_G(uuid, groupId); 325 } 326 327 /** 328 * Returns all the blogs entries where uuid = ? and companyId = ?. 329 * 330 * @param uuid the uuid 331 * @param companyId the company ID 332 * @return the matching blogs entries 333 */ 334 public static List<BlogsEntry> findByUuid_C(java.lang.String uuid, 335 long companyId) { 336 return getPersistence().findByUuid_C(uuid, companyId); 337 } 338 339 /** 340 * Returns a range of all the blogs entries where uuid = ? and companyId = ?. 341 * 342 * <p> 343 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 344 * </p> 345 * 346 * @param uuid the uuid 347 * @param companyId the company ID 348 * @param start the lower bound of the range of blogs entries 349 * @param end the upper bound of the range of blogs entries (not inclusive) 350 * @return the range of matching blogs entries 351 */ 352 public static List<BlogsEntry> findByUuid_C(java.lang.String uuid, 353 long companyId, int start, int end) { 354 return getPersistence().findByUuid_C(uuid, companyId, start, end); 355 } 356 357 /** 358 * Returns an ordered range of all the blogs entries where uuid = ? and companyId = ?. 359 * 360 * <p> 361 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 362 * </p> 363 * 364 * @param uuid the uuid 365 * @param companyId the company ID 366 * @param start the lower bound of the range of blogs entries 367 * @param end the upper bound of the range of blogs entries (not inclusive) 368 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 369 * @return the ordered range of matching blogs entries 370 */ 371 public static List<BlogsEntry> findByUuid_C(java.lang.String uuid, 372 long companyId, int start, int end, 373 OrderByComparator<BlogsEntry> orderByComparator) { 374 return getPersistence() 375 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 376 } 377 378 /** 379 * Returns an ordered range of all the blogs entries where uuid = ? and companyId = ?. 380 * 381 * <p> 382 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 383 * </p> 384 * 385 * @param uuid the uuid 386 * @param companyId the company ID 387 * @param start the lower bound of the range of blogs entries 388 * @param end the upper bound of the range of blogs entries (not inclusive) 389 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 390 * @param retrieveFromCache whether to retrieve from the finder cache 391 * @return the ordered range of matching blogs entries 392 */ 393 public static List<BlogsEntry> findByUuid_C(java.lang.String uuid, 394 long companyId, int start, int end, 395 OrderByComparator<BlogsEntry> orderByComparator, 396 boolean retrieveFromCache) { 397 return getPersistence() 398 .findByUuid_C(uuid, companyId, start, end, 399 orderByComparator, retrieveFromCache); 400 } 401 402 /** 403 * Returns the first blogs entry in the ordered set where uuid = ? and companyId = ?. 404 * 405 * @param uuid the uuid 406 * @param companyId the company ID 407 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 408 * @return the first matching blogs entry 409 * @throws NoSuchEntryException if a matching blogs entry could not be found 410 */ 411 public static BlogsEntry findByUuid_C_First(java.lang.String uuid, 412 long companyId, OrderByComparator<BlogsEntry> orderByComparator) 413 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 414 return getPersistence() 415 .findByUuid_C_First(uuid, companyId, orderByComparator); 416 } 417 418 /** 419 * Returns the first blogs entry in the ordered set where uuid = ? and companyId = ?. 420 * 421 * @param uuid the uuid 422 * @param companyId the company ID 423 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 424 * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 425 */ 426 public static BlogsEntry fetchByUuid_C_First(java.lang.String uuid, 427 long companyId, OrderByComparator<BlogsEntry> orderByComparator) { 428 return getPersistence() 429 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 430 } 431 432 /** 433 * Returns the last blogs entry in the ordered set where uuid = ? and companyId = ?. 434 * 435 * @param uuid the uuid 436 * @param companyId the company ID 437 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 438 * @return the last matching blogs entry 439 * @throws NoSuchEntryException if a matching blogs entry could not be found 440 */ 441 public static BlogsEntry findByUuid_C_Last(java.lang.String uuid, 442 long companyId, OrderByComparator<BlogsEntry> orderByComparator) 443 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 444 return getPersistence() 445 .findByUuid_C_Last(uuid, companyId, orderByComparator); 446 } 447 448 /** 449 * Returns the last blogs entry in the ordered set where uuid = ? and companyId = ?. 450 * 451 * @param uuid the uuid 452 * @param companyId the company ID 453 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 454 * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 455 */ 456 public static BlogsEntry fetchByUuid_C_Last(java.lang.String uuid, 457 long companyId, OrderByComparator<BlogsEntry> orderByComparator) { 458 return getPersistence() 459 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 460 } 461 462 /** 463 * Returns the blogs entries before and after the current blogs entry in the ordered set where uuid = ? and companyId = ?. 464 * 465 * @param entryId the primary key of the current blogs entry 466 * @param uuid the uuid 467 * @param companyId the company ID 468 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 469 * @return the previous, current, and next blogs entry 470 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 471 */ 472 public static BlogsEntry[] findByUuid_C_PrevAndNext(long entryId, 473 java.lang.String uuid, long companyId, 474 OrderByComparator<BlogsEntry> orderByComparator) 475 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 476 return getPersistence() 477 .findByUuid_C_PrevAndNext(entryId, uuid, companyId, 478 orderByComparator); 479 } 480 481 /** 482 * Removes all the blogs entries where uuid = ? and companyId = ? from the database. 483 * 484 * @param uuid the uuid 485 * @param companyId the company ID 486 */ 487 public static void removeByUuid_C(java.lang.String uuid, long companyId) { 488 getPersistence().removeByUuid_C(uuid, companyId); 489 } 490 491 /** 492 * Returns the number of blogs entries where uuid = ? and companyId = ?. 493 * 494 * @param uuid the uuid 495 * @param companyId the company ID 496 * @return the number of matching blogs entries 497 */ 498 public static int countByUuid_C(java.lang.String uuid, long companyId) { 499 return getPersistence().countByUuid_C(uuid, companyId); 500 } 501 502 /** 503 * Returns all the blogs entries where groupId = ?. 504 * 505 * @param groupId the group ID 506 * @return the matching blogs entries 507 */ 508 public static List<BlogsEntry> findByGroupId(long groupId) { 509 return getPersistence().findByGroupId(groupId); 510 } 511 512 /** 513 * Returns a range of all the blogs entries where groupId = ?. 514 * 515 * <p> 516 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 517 * </p> 518 * 519 * @param groupId the group ID 520 * @param start the lower bound of the range of blogs entries 521 * @param end the upper bound of the range of blogs entries (not inclusive) 522 * @return the range of matching blogs entries 523 */ 524 public static List<BlogsEntry> findByGroupId(long groupId, int start, 525 int end) { 526 return getPersistence().findByGroupId(groupId, start, end); 527 } 528 529 /** 530 * Returns an ordered range of all the blogs entries where groupId = ?. 531 * 532 * <p> 533 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 534 * </p> 535 * 536 * @param groupId the group ID 537 * @param start the lower bound of the range of blogs entries 538 * @param end the upper bound of the range of blogs entries (not inclusive) 539 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 540 * @return the ordered range of matching blogs entries 541 */ 542 public static List<BlogsEntry> findByGroupId(long groupId, int start, 543 int end, OrderByComparator<BlogsEntry> orderByComparator) { 544 return getPersistence() 545 .findByGroupId(groupId, start, end, orderByComparator); 546 } 547 548 /** 549 * Returns an ordered range of all the blogs entries where groupId = ?. 550 * 551 * <p> 552 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 553 * </p> 554 * 555 * @param groupId the group ID 556 * @param start the lower bound of the range of blogs entries 557 * @param end the upper bound of the range of blogs entries (not inclusive) 558 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 559 * @param retrieveFromCache whether to retrieve from the finder cache 560 * @return the ordered range of matching blogs entries 561 */ 562 public static List<BlogsEntry> findByGroupId(long groupId, int start, 563 int end, OrderByComparator<BlogsEntry> orderByComparator, 564 boolean retrieveFromCache) { 565 return getPersistence() 566 .findByGroupId(groupId, start, end, orderByComparator, 567 retrieveFromCache); 568 } 569 570 /** 571 * Returns the first blogs entry in the ordered set where groupId = ?. 572 * 573 * @param groupId the group ID 574 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 575 * @return the first matching blogs entry 576 * @throws NoSuchEntryException if a matching blogs entry could not be found 577 */ 578 public static BlogsEntry findByGroupId_First(long groupId, 579 OrderByComparator<BlogsEntry> orderByComparator) 580 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 581 return getPersistence().findByGroupId_First(groupId, orderByComparator); 582 } 583 584 /** 585 * Returns the first blogs entry in the ordered set where groupId = ?. 586 * 587 * @param groupId the group ID 588 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 589 * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 590 */ 591 public static BlogsEntry fetchByGroupId_First(long groupId, 592 OrderByComparator<BlogsEntry> orderByComparator) { 593 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 594 } 595 596 /** 597 * Returns the last blogs entry in the ordered set where groupId = ?. 598 * 599 * @param groupId the group ID 600 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 601 * @return the last matching blogs entry 602 * @throws NoSuchEntryException if a matching blogs entry could not be found 603 */ 604 public static BlogsEntry findByGroupId_Last(long groupId, 605 OrderByComparator<BlogsEntry> orderByComparator) 606 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 607 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 608 } 609 610 /** 611 * Returns the last blogs entry in the ordered set where groupId = ?. 612 * 613 * @param groupId the group ID 614 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 615 * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 616 */ 617 public static BlogsEntry fetchByGroupId_Last(long groupId, 618 OrderByComparator<BlogsEntry> orderByComparator) { 619 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 620 } 621 622 /** 623 * Returns the blogs entries before and after the current blogs entry in the ordered set where groupId = ?. 624 * 625 * @param entryId the primary key of the current blogs entry 626 * @param groupId the group ID 627 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 628 * @return the previous, current, and next blogs entry 629 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 630 */ 631 public static BlogsEntry[] findByGroupId_PrevAndNext(long entryId, 632 long groupId, OrderByComparator<BlogsEntry> orderByComparator) 633 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 634 return getPersistence() 635 .findByGroupId_PrevAndNext(entryId, groupId, 636 orderByComparator); 637 } 638 639 /** 640 * Returns all the blogs entries that the user has permission to view where groupId = ?. 641 * 642 * @param groupId the group ID 643 * @return the matching blogs entries that the user has permission to view 644 */ 645 public static List<BlogsEntry> filterFindByGroupId(long groupId) { 646 return getPersistence().filterFindByGroupId(groupId); 647 } 648 649 /** 650 * Returns a range of all the blogs entries that the user has permission to view where groupId = ?. 651 * 652 * <p> 653 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 654 * </p> 655 * 656 * @param groupId the group ID 657 * @param start the lower bound of the range of blogs entries 658 * @param end the upper bound of the range of blogs entries (not inclusive) 659 * @return the range of matching blogs entries that the user has permission to view 660 */ 661 public static List<BlogsEntry> filterFindByGroupId(long groupId, int start, 662 int end) { 663 return getPersistence().filterFindByGroupId(groupId, start, end); 664 } 665 666 /** 667 * Returns an ordered range of all the blogs entries that the user has permissions to view where groupId = ?. 668 * 669 * <p> 670 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 671 * </p> 672 * 673 * @param groupId the group ID 674 * @param start the lower bound of the range of blogs entries 675 * @param end the upper bound of the range of blogs entries (not inclusive) 676 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 677 * @return the ordered range of matching blogs entries that the user has permission to view 678 */ 679 public static List<BlogsEntry> filterFindByGroupId(long groupId, int start, 680 int end, OrderByComparator<BlogsEntry> orderByComparator) { 681 return getPersistence() 682 .filterFindByGroupId(groupId, start, end, orderByComparator); 683 } 684 685 /** 686 * 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 = ?. 687 * 688 * @param entryId the primary key of the current blogs entry 689 * @param groupId the group ID 690 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 691 * @return the previous, current, and next blogs entry 692 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 693 */ 694 public static BlogsEntry[] filterFindByGroupId_PrevAndNext(long entryId, 695 long groupId, OrderByComparator<BlogsEntry> orderByComparator) 696 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 697 return getPersistence() 698 .filterFindByGroupId_PrevAndNext(entryId, groupId, 699 orderByComparator); 700 } 701 702 /** 703 * Removes all the blogs entries where groupId = ? from the database. 704 * 705 * @param groupId the group ID 706 */ 707 public static void removeByGroupId(long groupId) { 708 getPersistence().removeByGroupId(groupId); 709 } 710 711 /** 712 * Returns the number of blogs entries where groupId = ?. 713 * 714 * @param groupId the group ID 715 * @return the number of matching blogs entries 716 */ 717 public static int countByGroupId(long groupId) { 718 return getPersistence().countByGroupId(groupId); 719 } 720 721 /** 722 * Returns the number of blogs entries that the user has permission to view where groupId = ?. 723 * 724 * @param groupId the group ID 725 * @return the number of matching blogs entries that the user has permission to view 726 */ 727 public static int filterCountByGroupId(long groupId) { 728 return getPersistence().filterCountByGroupId(groupId); 729 } 730 731 /** 732 * Returns all the blogs entries where companyId = ?. 733 * 734 * @param companyId the company ID 735 * @return the matching blogs entries 736 */ 737 public static List<BlogsEntry> findByCompanyId(long companyId) { 738 return getPersistence().findByCompanyId(companyId); 739 } 740 741 /** 742 * Returns a range of all the blogs entries where companyId = ?. 743 * 744 * <p> 745 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 746 * </p> 747 * 748 * @param companyId the company ID 749 * @param start the lower bound of the range of blogs entries 750 * @param end the upper bound of the range of blogs entries (not inclusive) 751 * @return the range of matching blogs entries 752 */ 753 public static List<BlogsEntry> findByCompanyId(long companyId, int start, 754 int end) { 755 return getPersistence().findByCompanyId(companyId, start, end); 756 } 757 758 /** 759 * Returns an ordered range of all the blogs entries where companyId = ?. 760 * 761 * <p> 762 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 763 * </p> 764 * 765 * @param companyId the company ID 766 * @param start the lower bound of the range of blogs entries 767 * @param end the upper bound of the range of blogs entries (not inclusive) 768 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 769 * @return the ordered range of matching blogs entries 770 */ 771 public static List<BlogsEntry> findByCompanyId(long companyId, int start, 772 int end, OrderByComparator<BlogsEntry> orderByComparator) { 773 return getPersistence() 774 .findByCompanyId(companyId, start, end, orderByComparator); 775 } 776 777 /** 778 * Returns an ordered range of all the blogs entries where companyId = ?. 779 * 780 * <p> 781 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 782 * </p> 783 * 784 * @param companyId the company ID 785 * @param start the lower bound of the range of blogs entries 786 * @param end the upper bound of the range of blogs entries (not inclusive) 787 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 788 * @param retrieveFromCache whether to retrieve from the finder cache 789 * @return the ordered range of matching blogs entries 790 */ 791 public static List<BlogsEntry> findByCompanyId(long companyId, int start, 792 int end, OrderByComparator<BlogsEntry> orderByComparator, 793 boolean retrieveFromCache) { 794 return getPersistence() 795 .findByCompanyId(companyId, start, end, orderByComparator, 796 retrieveFromCache); 797 } 798 799 /** 800 * Returns the first blogs entry in the ordered set where companyId = ?. 801 * 802 * @param companyId the company ID 803 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 804 * @return the first matching blogs entry 805 * @throws NoSuchEntryException if a matching blogs entry could not be found 806 */ 807 public static BlogsEntry findByCompanyId_First(long companyId, 808 OrderByComparator<BlogsEntry> orderByComparator) 809 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 810 return getPersistence() 811 .findByCompanyId_First(companyId, orderByComparator); 812 } 813 814 /** 815 * Returns the first blogs entry in the ordered set where companyId = ?. 816 * 817 * @param companyId the company ID 818 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 819 * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 820 */ 821 public static BlogsEntry fetchByCompanyId_First(long companyId, 822 OrderByComparator<BlogsEntry> orderByComparator) { 823 return getPersistence() 824 .fetchByCompanyId_First(companyId, orderByComparator); 825 } 826 827 /** 828 * Returns the last blogs entry in the ordered set where companyId = ?. 829 * 830 * @param companyId the company ID 831 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 832 * @return the last matching blogs entry 833 * @throws NoSuchEntryException if a matching blogs entry could not be found 834 */ 835 public static BlogsEntry findByCompanyId_Last(long companyId, 836 OrderByComparator<BlogsEntry> orderByComparator) 837 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 838 return getPersistence() 839 .findByCompanyId_Last(companyId, orderByComparator); 840 } 841 842 /** 843 * Returns the last blogs entry in the ordered set where companyId = ?. 844 * 845 * @param companyId the company ID 846 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 847 * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 848 */ 849 public static BlogsEntry fetchByCompanyId_Last(long companyId, 850 OrderByComparator<BlogsEntry> orderByComparator) { 851 return getPersistence() 852 .fetchByCompanyId_Last(companyId, orderByComparator); 853 } 854 855 /** 856 * Returns the blogs entries before and after the current blogs entry in the ordered set where companyId = ?. 857 * 858 * @param entryId the primary key of the current blogs entry 859 * @param companyId the company ID 860 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 861 * @return the previous, current, and next blogs entry 862 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 863 */ 864 public static BlogsEntry[] findByCompanyId_PrevAndNext(long entryId, 865 long companyId, OrderByComparator<BlogsEntry> orderByComparator) 866 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 867 return getPersistence() 868 .findByCompanyId_PrevAndNext(entryId, companyId, 869 orderByComparator); 870 } 871 872 /** 873 * Removes all the blogs entries where companyId = ? from the database. 874 * 875 * @param companyId the company ID 876 */ 877 public static void removeByCompanyId(long companyId) { 878 getPersistence().removeByCompanyId(companyId); 879 } 880 881 /** 882 * Returns the number of blogs entries where companyId = ?. 883 * 884 * @param companyId the company ID 885 * @return the number of matching blogs entries 886 */ 887 public static int countByCompanyId(long companyId) { 888 return getPersistence().countByCompanyId(companyId); 889 } 890 891 /** 892 * Returns the blogs entry where groupId = ? and urlTitle = ? or throws a {@link NoSuchEntryException} if it could not be found. 893 * 894 * @param groupId the group ID 895 * @param urlTitle the url title 896 * @return the matching blogs entry 897 * @throws NoSuchEntryException if a matching blogs entry could not be found 898 */ 899 public static BlogsEntry findByG_UT(long groupId, java.lang.String urlTitle) 900 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 901 return getPersistence().findByG_UT(groupId, urlTitle); 902 } 903 904 /** 905 * Returns the blogs entry where groupId = ? and urlTitle = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 906 * 907 * @param groupId the group ID 908 * @param urlTitle the url title 909 * @return the matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 910 */ 911 public static BlogsEntry fetchByG_UT(long groupId, java.lang.String urlTitle) { 912 return getPersistence().fetchByG_UT(groupId, urlTitle); 913 } 914 915 /** 916 * Returns the blogs entry where groupId = ? and urlTitle = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 917 * 918 * @param groupId the group ID 919 * @param urlTitle the url title 920 * @param retrieveFromCache whether to retrieve from the finder cache 921 * @return the matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 922 */ 923 public static BlogsEntry fetchByG_UT(long groupId, 924 java.lang.String urlTitle, boolean retrieveFromCache) { 925 return getPersistence().fetchByG_UT(groupId, urlTitle, retrieveFromCache); 926 } 927 928 /** 929 * Removes the blogs entry where groupId = ? and urlTitle = ? from the database. 930 * 931 * @param groupId the group ID 932 * @param urlTitle the url title 933 * @return the blogs entry that was removed 934 */ 935 public static BlogsEntry removeByG_UT(long groupId, 936 java.lang.String urlTitle) 937 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 938 return getPersistence().removeByG_UT(groupId, urlTitle); 939 } 940 941 /** 942 * Returns the number of blogs entries where groupId = ? and urlTitle = ?. 943 * 944 * @param groupId the group ID 945 * @param urlTitle the url title 946 * @return the number of matching blogs entries 947 */ 948 public static int countByG_UT(long groupId, java.lang.String urlTitle) { 949 return getPersistence().countByG_UT(groupId, urlTitle); 950 } 951 952 /** 953 * Returns all the blogs entries where groupId = ? and displayDate < ?. 954 * 955 * @param groupId the group ID 956 * @param displayDate the display date 957 * @return the matching blogs entries 958 */ 959 public static List<BlogsEntry> findByG_LtD(long groupId, Date displayDate) { 960 return getPersistence().findByG_LtD(groupId, displayDate); 961 } 962 963 /** 964 * Returns a range of all the blogs entries where groupId = ? and displayDate < ?. 965 * 966 * <p> 967 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 968 * </p> 969 * 970 * @param groupId the group ID 971 * @param displayDate the display date 972 * @param start the lower bound of the range of blogs entries 973 * @param end the upper bound of the range of blogs entries (not inclusive) 974 * @return the range of matching blogs entries 975 */ 976 public static List<BlogsEntry> findByG_LtD(long groupId, Date displayDate, 977 int start, int end) { 978 return getPersistence().findByG_LtD(groupId, displayDate, start, end); 979 } 980 981 /** 982 * Returns an ordered range of all the blogs entries where groupId = ? and displayDate < ?. 983 * 984 * <p> 985 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 986 * </p> 987 * 988 * @param groupId the group ID 989 * @param displayDate the display date 990 * @param start the lower bound of the range of blogs entries 991 * @param end the upper bound of the range of blogs entries (not inclusive) 992 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 993 * @return the ordered range of matching blogs entries 994 */ 995 public static List<BlogsEntry> findByG_LtD(long groupId, Date displayDate, 996 int start, int end, OrderByComparator<BlogsEntry> orderByComparator) { 997 return getPersistence() 998 .findByG_LtD(groupId, displayDate, start, end, 999 orderByComparator); 1000 } 1001 1002 /** 1003 * Returns an ordered range of all the blogs entries where groupId = ? and displayDate < ?. 1004 * 1005 * <p> 1006 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1007 * </p> 1008 * 1009 * @param groupId the group ID 1010 * @param displayDate the display date 1011 * @param start the lower bound of the range of blogs entries 1012 * @param end the upper bound of the range of blogs entries (not inclusive) 1013 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1014 * @param retrieveFromCache whether to retrieve from the finder cache 1015 * @return the ordered range of matching blogs entries 1016 */ 1017 public static List<BlogsEntry> findByG_LtD(long groupId, Date displayDate, 1018 int start, int end, OrderByComparator<BlogsEntry> orderByComparator, 1019 boolean retrieveFromCache) { 1020 return getPersistence() 1021 .findByG_LtD(groupId, displayDate, start, end, 1022 orderByComparator, retrieveFromCache); 1023 } 1024 1025 /** 1026 * Returns the first blogs entry in the ordered set where groupId = ? and displayDate < ?. 1027 * 1028 * @param groupId the group ID 1029 * @param displayDate the display date 1030 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1031 * @return the first matching blogs entry 1032 * @throws NoSuchEntryException if a matching blogs entry could not be found 1033 */ 1034 public static BlogsEntry findByG_LtD_First(long groupId, Date displayDate, 1035 OrderByComparator<BlogsEntry> orderByComparator) 1036 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 1037 return getPersistence() 1038 .findByG_LtD_First(groupId, displayDate, orderByComparator); 1039 } 1040 1041 /** 1042 * Returns the first blogs entry in the ordered set where groupId = ? and displayDate < ?. 1043 * 1044 * @param groupId the group ID 1045 * @param displayDate the display date 1046 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1047 * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 1048 */ 1049 public static BlogsEntry fetchByG_LtD_First(long groupId, Date displayDate, 1050 OrderByComparator<BlogsEntry> orderByComparator) { 1051 return getPersistence() 1052 .fetchByG_LtD_First(groupId, displayDate, orderByComparator); 1053 } 1054 1055 /** 1056 * Returns the last blogs entry in the ordered set where groupId = ? and displayDate < ?. 1057 * 1058 * @param groupId the group ID 1059 * @param displayDate the display date 1060 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1061 * @return the last matching blogs entry 1062 * @throws NoSuchEntryException if a matching blogs entry could not be found 1063 */ 1064 public static BlogsEntry findByG_LtD_Last(long groupId, Date displayDate, 1065 OrderByComparator<BlogsEntry> orderByComparator) 1066 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 1067 return getPersistence() 1068 .findByG_LtD_Last(groupId, displayDate, orderByComparator); 1069 } 1070 1071 /** 1072 * Returns the last blogs entry in the ordered set where groupId = ? and displayDate < ?. 1073 * 1074 * @param groupId the group ID 1075 * @param displayDate the display date 1076 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1077 * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 1078 */ 1079 public static BlogsEntry fetchByG_LtD_Last(long groupId, Date displayDate, 1080 OrderByComparator<BlogsEntry> orderByComparator) { 1081 return getPersistence() 1082 .fetchByG_LtD_Last(groupId, displayDate, orderByComparator); 1083 } 1084 1085 /** 1086 * Returns the blogs entries before and after the current blogs entry in the ordered set where groupId = ? and displayDate < ?. 1087 * 1088 * @param entryId the primary key of the current blogs entry 1089 * @param groupId the group ID 1090 * @param displayDate the display date 1091 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1092 * @return the previous, current, and next blogs entry 1093 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 1094 */ 1095 public static BlogsEntry[] findByG_LtD_PrevAndNext(long entryId, 1096 long groupId, Date displayDate, 1097 OrderByComparator<BlogsEntry> orderByComparator) 1098 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 1099 return getPersistence() 1100 .findByG_LtD_PrevAndNext(entryId, groupId, displayDate, 1101 orderByComparator); 1102 } 1103 1104 /** 1105 * Returns all the blogs entries that the user has permission to view where groupId = ? and displayDate < ?. 1106 * 1107 * @param groupId the group ID 1108 * @param displayDate the display date 1109 * @return the matching blogs entries that the user has permission to view 1110 */ 1111 public static List<BlogsEntry> filterFindByG_LtD(long groupId, 1112 Date displayDate) { 1113 return getPersistence().filterFindByG_LtD(groupId, displayDate); 1114 } 1115 1116 /** 1117 * Returns a range of all the blogs entries that the user has permission to view where groupId = ? and displayDate < ?. 1118 * 1119 * <p> 1120 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1121 * </p> 1122 * 1123 * @param groupId the group ID 1124 * @param displayDate the display date 1125 * @param start the lower bound of the range of blogs entries 1126 * @param end the upper bound of the range of blogs entries (not inclusive) 1127 * @return the range of matching blogs entries that the user has permission to view 1128 */ 1129 public static List<BlogsEntry> filterFindByG_LtD(long groupId, 1130 Date displayDate, int start, int end) { 1131 return getPersistence() 1132 .filterFindByG_LtD(groupId, displayDate, start, end); 1133 } 1134 1135 /** 1136 * Returns an ordered range of all the blogs entries that the user has permissions to view where groupId = ? and displayDate < ?. 1137 * 1138 * <p> 1139 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1140 * </p> 1141 * 1142 * @param groupId the group ID 1143 * @param displayDate the display date 1144 * @param start the lower bound of the range of blogs entries 1145 * @param end the upper bound of the range of blogs entries (not inclusive) 1146 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1147 * @return the ordered range of matching blogs entries that the user has permission to view 1148 */ 1149 public static List<BlogsEntry> filterFindByG_LtD(long groupId, 1150 Date displayDate, int start, int end, 1151 OrderByComparator<BlogsEntry> orderByComparator) { 1152 return getPersistence() 1153 .filterFindByG_LtD(groupId, displayDate, start, end, 1154 orderByComparator); 1155 } 1156 1157 /** 1158 * 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 < ?. 1159 * 1160 * @param entryId the primary key of the current blogs entry 1161 * @param groupId the group ID 1162 * @param displayDate the display date 1163 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1164 * @return the previous, current, and next blogs entry 1165 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 1166 */ 1167 public static BlogsEntry[] filterFindByG_LtD_PrevAndNext(long entryId, 1168 long groupId, Date displayDate, 1169 OrderByComparator<BlogsEntry> orderByComparator) 1170 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 1171 return getPersistence() 1172 .filterFindByG_LtD_PrevAndNext(entryId, groupId, 1173 displayDate, orderByComparator); 1174 } 1175 1176 /** 1177 * Removes all the blogs entries where groupId = ? and displayDate < ? from the database. 1178 * 1179 * @param groupId the group ID 1180 * @param displayDate the display date 1181 */ 1182 public static void removeByG_LtD(long groupId, Date displayDate) { 1183 getPersistence().removeByG_LtD(groupId, displayDate); 1184 } 1185 1186 /** 1187 * Returns the number of blogs entries where groupId = ? and displayDate < ?. 1188 * 1189 * @param groupId the group ID 1190 * @param displayDate the display date 1191 * @return the number of matching blogs entries 1192 */ 1193 public static int countByG_LtD(long groupId, Date displayDate) { 1194 return getPersistence().countByG_LtD(groupId, displayDate); 1195 } 1196 1197 /** 1198 * Returns the number of blogs entries that the user has permission to view where groupId = ? and displayDate < ?. 1199 * 1200 * @param groupId the group ID 1201 * @param displayDate the display date 1202 * @return the number of matching blogs entries that the user has permission to view 1203 */ 1204 public static int filterCountByG_LtD(long groupId, Date displayDate) { 1205 return getPersistence().filterCountByG_LtD(groupId, displayDate); 1206 } 1207 1208 /** 1209 * Returns all the blogs entries where groupId = ? and status = ?. 1210 * 1211 * @param groupId the group ID 1212 * @param status the status 1213 * @return the matching blogs entries 1214 */ 1215 public static List<BlogsEntry> findByG_S(long groupId, int status) { 1216 return getPersistence().findByG_S(groupId, status); 1217 } 1218 1219 /** 1220 * Returns a range of all the blogs entries where groupId = ? and status = ?. 1221 * 1222 * <p> 1223 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1224 * </p> 1225 * 1226 * @param groupId the group ID 1227 * @param status the status 1228 * @param start the lower bound of the range of blogs entries 1229 * @param end the upper bound of the range of blogs entries (not inclusive) 1230 * @return the range of matching blogs entries 1231 */ 1232 public static List<BlogsEntry> findByG_S(long groupId, int status, 1233 int start, int end) { 1234 return getPersistence().findByG_S(groupId, status, start, end); 1235 } 1236 1237 /** 1238 * Returns an ordered range of all the blogs entries where groupId = ? and status = ?. 1239 * 1240 * <p> 1241 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1242 * </p> 1243 * 1244 * @param groupId the group ID 1245 * @param status the status 1246 * @param start the lower bound of the range of blogs entries 1247 * @param end the upper bound of the range of blogs entries (not inclusive) 1248 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1249 * @return the ordered range of matching blogs entries 1250 */ 1251 public static List<BlogsEntry> findByG_S(long groupId, int status, 1252 int start, int end, OrderByComparator<BlogsEntry> orderByComparator) { 1253 return getPersistence() 1254 .findByG_S(groupId, status, start, end, orderByComparator); 1255 } 1256 1257 /** 1258 * Returns an ordered range of all the blogs entries where groupId = ? and status = ?. 1259 * 1260 * <p> 1261 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1262 * </p> 1263 * 1264 * @param groupId the group ID 1265 * @param status the status 1266 * @param start the lower bound of the range of blogs entries 1267 * @param end the upper bound of the range of blogs entries (not inclusive) 1268 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1269 * @param retrieveFromCache whether to retrieve from the finder cache 1270 * @return the ordered range of matching blogs entries 1271 */ 1272 public static List<BlogsEntry> findByG_S(long groupId, int status, 1273 int start, int end, OrderByComparator<BlogsEntry> orderByComparator, 1274 boolean retrieveFromCache) { 1275 return getPersistence() 1276 .findByG_S(groupId, status, start, end, orderByComparator, 1277 retrieveFromCache); 1278 } 1279 1280 /** 1281 * Returns the first blogs entry in the ordered set where groupId = ? and status = ?. 1282 * 1283 * @param groupId the group ID 1284 * @param status the status 1285 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1286 * @return the first matching blogs entry 1287 * @throws NoSuchEntryException if a matching blogs entry could not be found 1288 */ 1289 public static BlogsEntry findByG_S_First(long groupId, int status, 1290 OrderByComparator<BlogsEntry> orderByComparator) 1291 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 1292 return getPersistence() 1293 .findByG_S_First(groupId, status, orderByComparator); 1294 } 1295 1296 /** 1297 * Returns the first blogs entry in the ordered set where groupId = ? and status = ?. 1298 * 1299 * @param groupId the group ID 1300 * @param status the status 1301 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1302 * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 1303 */ 1304 public static BlogsEntry fetchByG_S_First(long groupId, int status, 1305 OrderByComparator<BlogsEntry> orderByComparator) { 1306 return getPersistence() 1307 .fetchByG_S_First(groupId, status, orderByComparator); 1308 } 1309 1310 /** 1311 * Returns the last blogs entry in the ordered set where groupId = ? and status = ?. 1312 * 1313 * @param groupId the group ID 1314 * @param status the status 1315 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1316 * @return the last matching blogs entry 1317 * @throws NoSuchEntryException if a matching blogs entry could not be found 1318 */ 1319 public static BlogsEntry findByG_S_Last(long groupId, int status, 1320 OrderByComparator<BlogsEntry> orderByComparator) 1321 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 1322 return getPersistence() 1323 .findByG_S_Last(groupId, status, orderByComparator); 1324 } 1325 1326 /** 1327 * Returns the last blogs entry in the ordered set where groupId = ? and status = ?. 1328 * 1329 * @param groupId the group ID 1330 * @param status the status 1331 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1332 * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 1333 */ 1334 public static BlogsEntry fetchByG_S_Last(long groupId, int status, 1335 OrderByComparator<BlogsEntry> orderByComparator) { 1336 return getPersistence() 1337 .fetchByG_S_Last(groupId, status, orderByComparator); 1338 } 1339 1340 /** 1341 * Returns the blogs entries before and after the current blogs entry in the ordered set where groupId = ? and status = ?. 1342 * 1343 * @param entryId the primary key of the current blogs entry 1344 * @param groupId the group ID 1345 * @param status the status 1346 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1347 * @return the previous, current, and next blogs entry 1348 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 1349 */ 1350 public static BlogsEntry[] findByG_S_PrevAndNext(long entryId, 1351 long groupId, int status, 1352 OrderByComparator<BlogsEntry> orderByComparator) 1353 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 1354 return getPersistence() 1355 .findByG_S_PrevAndNext(entryId, groupId, status, 1356 orderByComparator); 1357 } 1358 1359 /** 1360 * Returns all the blogs entries that the user has permission to view where groupId = ? and status = ?. 1361 * 1362 * @param groupId the group ID 1363 * @param status the status 1364 * @return the matching blogs entries that the user has permission to view 1365 */ 1366 public static List<BlogsEntry> filterFindByG_S(long groupId, int status) { 1367 return getPersistence().filterFindByG_S(groupId, status); 1368 } 1369 1370 /** 1371 * Returns a range of all the blogs entries that the user has permission to view where groupId = ? and status = ?. 1372 * 1373 * <p> 1374 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1375 * </p> 1376 * 1377 * @param groupId the group ID 1378 * @param status the status 1379 * @param start the lower bound of the range of blogs entries 1380 * @param end the upper bound of the range of blogs entries (not inclusive) 1381 * @return the range of matching blogs entries that the user has permission to view 1382 */ 1383 public static List<BlogsEntry> filterFindByG_S(long groupId, int status, 1384 int start, int end) { 1385 return getPersistence().filterFindByG_S(groupId, status, start, end); 1386 } 1387 1388 /** 1389 * Returns an ordered range of all the blogs entries that the user has permissions to view where groupId = ? and status = ?. 1390 * 1391 * <p> 1392 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1393 * </p> 1394 * 1395 * @param groupId the group ID 1396 * @param status the status 1397 * @param start the lower bound of the range of blogs entries 1398 * @param end the upper bound of the range of blogs entries (not inclusive) 1399 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1400 * @return the ordered range of matching blogs entries that the user has permission to view 1401 */ 1402 public static List<BlogsEntry> filterFindByG_S(long groupId, int status, 1403 int start, int end, OrderByComparator<BlogsEntry> orderByComparator) { 1404 return getPersistence() 1405 .filterFindByG_S(groupId, status, start, end, 1406 orderByComparator); 1407 } 1408 1409 /** 1410 * 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 = ?. 1411 * 1412 * @param entryId the primary key of the current blogs entry 1413 * @param groupId the group ID 1414 * @param status the status 1415 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1416 * @return the previous, current, and next blogs entry 1417 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 1418 */ 1419 public static BlogsEntry[] filterFindByG_S_PrevAndNext(long entryId, 1420 long groupId, int status, 1421 OrderByComparator<BlogsEntry> orderByComparator) 1422 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 1423 return getPersistence() 1424 .filterFindByG_S_PrevAndNext(entryId, groupId, status, 1425 orderByComparator); 1426 } 1427 1428 /** 1429 * Removes all the blogs entries where groupId = ? and status = ? from the database. 1430 * 1431 * @param groupId the group ID 1432 * @param status the status 1433 */ 1434 public static void removeByG_S(long groupId, int status) { 1435 getPersistence().removeByG_S(groupId, status); 1436 } 1437 1438 /** 1439 * Returns the number of blogs entries where groupId = ? and status = ?. 1440 * 1441 * @param groupId the group ID 1442 * @param status the status 1443 * @return the number of matching blogs entries 1444 */ 1445 public static int countByG_S(long groupId, int status) { 1446 return getPersistence().countByG_S(groupId, status); 1447 } 1448 1449 /** 1450 * Returns the number of blogs entries that the user has permission to view where groupId = ? and status = ?. 1451 * 1452 * @param groupId the group ID 1453 * @param status the status 1454 * @return the number of matching blogs entries that the user has permission to view 1455 */ 1456 public static int filterCountByG_S(long groupId, int status) { 1457 return getPersistence().filterCountByG_S(groupId, status); 1458 } 1459 1460 /** 1461 * Returns all the blogs entries where groupId = ? and status ≠ ?. 1462 * 1463 * @param groupId the group ID 1464 * @param status the status 1465 * @return the matching blogs entries 1466 */ 1467 public static List<BlogsEntry> findByG_NotS(long groupId, int status) { 1468 return getPersistence().findByG_NotS(groupId, status); 1469 } 1470 1471 /** 1472 * Returns a range of all the blogs entries where groupId = ? and status ≠ ?. 1473 * 1474 * <p> 1475 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1476 * </p> 1477 * 1478 * @param groupId the group ID 1479 * @param status the status 1480 * @param start the lower bound of the range of blogs entries 1481 * @param end the upper bound of the range of blogs entries (not inclusive) 1482 * @return the range of matching blogs entries 1483 */ 1484 public static List<BlogsEntry> findByG_NotS(long groupId, int status, 1485 int start, int end) { 1486 return getPersistence().findByG_NotS(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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 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 */ 1503 public static List<BlogsEntry> findByG_NotS(long groupId, int status, 1504 int start, int end, OrderByComparator<BlogsEntry> orderByComparator) { 1505 return getPersistence() 1506 .findByG_NotS(groupId, status, start, end, orderByComparator); 1507 } 1508 1509 /** 1510 * Returns an ordered range of all the blogs entries where groupId = ? and status ≠ ?. 1511 * 1512 * <p> 1513 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1514 * </p> 1515 * 1516 * @param groupId the group ID 1517 * @param status the status 1518 * @param start the lower bound of the range of blogs entries 1519 * @param end the upper bound of the range of blogs entries (not inclusive) 1520 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1521 * @param retrieveFromCache whether to retrieve from the finder cache 1522 * @return the ordered range of matching blogs entries 1523 */ 1524 public static List<BlogsEntry> findByG_NotS(long groupId, int status, 1525 int start, int end, OrderByComparator<BlogsEntry> orderByComparator, 1526 boolean retrieveFromCache) { 1527 return getPersistence() 1528 .findByG_NotS(groupId, status, start, end, 1529 orderByComparator, retrieveFromCache); 1530 } 1531 1532 /** 1533 * Returns the first blogs entry in the ordered set where groupId = ? and status ≠ ?. 1534 * 1535 * @param groupId the group ID 1536 * @param status the status 1537 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1538 * @return the first matching blogs entry 1539 * @throws NoSuchEntryException if a matching blogs entry could not be found 1540 */ 1541 public static BlogsEntry findByG_NotS_First(long groupId, int status, 1542 OrderByComparator<BlogsEntry> orderByComparator) 1543 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 1544 return getPersistence() 1545 .findByG_NotS_First(groupId, status, orderByComparator); 1546 } 1547 1548 /** 1549 * Returns the first 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 first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 1555 */ 1556 public static BlogsEntry fetchByG_NotS_First(long groupId, int status, 1557 OrderByComparator<BlogsEntry> orderByComparator) { 1558 return getPersistence() 1559 .fetchByG_NotS_First(groupId, status, orderByComparator); 1560 } 1561 1562 /** 1563 * Returns the last blogs entry in the ordered set where groupId = ? and status ≠ ?. 1564 * 1565 * @param groupId the group ID 1566 * @param status the status 1567 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1568 * @return the last matching blogs entry 1569 * @throws NoSuchEntryException if a matching blogs entry could not be found 1570 */ 1571 public static BlogsEntry findByG_NotS_Last(long groupId, int status, 1572 OrderByComparator<BlogsEntry> orderByComparator) 1573 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 1574 return getPersistence() 1575 .findByG_NotS_Last(groupId, status, orderByComparator); 1576 } 1577 1578 /** 1579 * Returns the last blogs entry in the ordered set where groupId = ? and status ≠ ?. 1580 * 1581 * @param groupId the group ID 1582 * @param status the status 1583 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1584 * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 1585 */ 1586 public static BlogsEntry fetchByG_NotS_Last(long groupId, int status, 1587 OrderByComparator<BlogsEntry> orderByComparator) { 1588 return getPersistence() 1589 .fetchByG_NotS_Last(groupId, status, orderByComparator); 1590 } 1591 1592 /** 1593 * Returns the blogs entries before and after the current blogs entry in the ordered set where groupId = ? and status ≠ ?. 1594 * 1595 * @param entryId the primary key of the current blogs entry 1596 * @param groupId the group ID 1597 * @param status the status 1598 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1599 * @return the previous, current, and next blogs entry 1600 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 1601 */ 1602 public static BlogsEntry[] findByG_NotS_PrevAndNext(long entryId, 1603 long groupId, int status, 1604 OrderByComparator<BlogsEntry> orderByComparator) 1605 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 1606 return getPersistence() 1607 .findByG_NotS_PrevAndNext(entryId, groupId, status, 1608 orderByComparator); 1609 } 1610 1611 /** 1612 * Returns all the blogs entries that the user has permission to view where groupId = ? and status ≠ ?. 1613 * 1614 * @param groupId the group ID 1615 * @param status the status 1616 * @return the matching blogs entries that the user has permission to view 1617 */ 1618 public static List<BlogsEntry> filterFindByG_NotS(long groupId, int status) { 1619 return getPersistence().filterFindByG_NotS(groupId, status); 1620 } 1621 1622 /** 1623 * Returns a range of all the blogs entries that the user has permission to view where groupId = ? and status ≠ ?. 1624 * 1625 * <p> 1626 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1627 * </p> 1628 * 1629 * @param groupId the group ID 1630 * @param status the status 1631 * @param start the lower bound of the range of blogs entries 1632 * @param end the upper bound of the range of blogs entries (not inclusive) 1633 * @return the range of matching blogs entries that the user has permission to view 1634 */ 1635 public static List<BlogsEntry> filterFindByG_NotS(long groupId, int status, 1636 int start, int end) { 1637 return getPersistence().filterFindByG_NotS(groupId, status, start, end); 1638 } 1639 1640 /** 1641 * Returns an ordered range of all the blogs entries that the user has permissions to view where groupId = ? and status ≠ ?. 1642 * 1643 * <p> 1644 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1645 * </p> 1646 * 1647 * @param groupId the group ID 1648 * @param status the status 1649 * @param start the lower bound of the range of blogs entries 1650 * @param end the upper bound of the range of blogs entries (not inclusive) 1651 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1652 * @return the ordered range of matching blogs entries that the user has permission to view 1653 */ 1654 public static List<BlogsEntry> filterFindByG_NotS(long groupId, int status, 1655 int start, int end, OrderByComparator<BlogsEntry> orderByComparator) { 1656 return getPersistence() 1657 .filterFindByG_NotS(groupId, status, start, end, 1658 orderByComparator); 1659 } 1660 1661 /** 1662 * 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 ≠ ?. 1663 * 1664 * @param entryId the primary key of the current blogs entry 1665 * @param groupId the group ID 1666 * @param status the status 1667 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1668 * @return the previous, current, and next blogs entry 1669 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 1670 */ 1671 public static BlogsEntry[] filterFindByG_NotS_PrevAndNext(long entryId, 1672 long groupId, int status, 1673 OrderByComparator<BlogsEntry> orderByComparator) 1674 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 1675 return getPersistence() 1676 .filterFindByG_NotS_PrevAndNext(entryId, groupId, status, 1677 orderByComparator); 1678 } 1679 1680 /** 1681 * Removes all the blogs entries where groupId = ? and status ≠ ? from the database. 1682 * 1683 * @param groupId the group ID 1684 * @param status the status 1685 */ 1686 public static void removeByG_NotS(long groupId, int status) { 1687 getPersistence().removeByG_NotS(groupId, status); 1688 } 1689 1690 /** 1691 * Returns the number of blogs entries where groupId = ? and status ≠ ?. 1692 * 1693 * @param groupId the group ID 1694 * @param status the status 1695 * @return the number of matching blogs entries 1696 */ 1697 public static int countByG_NotS(long groupId, int status) { 1698 return getPersistence().countByG_NotS(groupId, status); 1699 } 1700 1701 /** 1702 * Returns the number of blogs entries that the user has permission to view where groupId = ? and status ≠ ?. 1703 * 1704 * @param groupId the group ID 1705 * @param status the status 1706 * @return the number of matching blogs entries that the user has permission to view 1707 */ 1708 public static int filterCountByG_NotS(long groupId, int status) { 1709 return getPersistence().filterCountByG_NotS(groupId, status); 1710 } 1711 1712 /** 1713 * Returns all the blogs entries where companyId = ? and userId = ?. 1714 * 1715 * @param companyId the company ID 1716 * @param userId the user ID 1717 * @return the matching blogs entries 1718 */ 1719 public static List<BlogsEntry> findByC_U(long companyId, long userId) { 1720 return getPersistence().findByC_U(companyId, userId); 1721 } 1722 1723 /** 1724 * Returns a range of all the blogs entries where companyId = ? and userId = ?. 1725 * 1726 * <p> 1727 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1728 * </p> 1729 * 1730 * @param companyId the company ID 1731 * @param userId the user ID 1732 * @param start the lower bound of the range of blogs entries 1733 * @param end the upper bound of the range of blogs entries (not inclusive) 1734 * @return the range of matching blogs entries 1735 */ 1736 public static List<BlogsEntry> findByC_U(long companyId, long userId, 1737 int start, int end) { 1738 return getPersistence().findByC_U(companyId, userId, start, end); 1739 } 1740 1741 /** 1742 * Returns an ordered range of all the blogs entries where companyId = ? and userId = ?. 1743 * 1744 * <p> 1745 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1746 * </p> 1747 * 1748 * @param companyId the company ID 1749 * @param userId the user ID 1750 * @param start the lower bound of the range of blogs entries 1751 * @param end the upper bound of the range of blogs entries (not inclusive) 1752 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1753 * @return the ordered range of matching blogs entries 1754 */ 1755 public static List<BlogsEntry> findByC_U(long companyId, long userId, 1756 int start, int end, OrderByComparator<BlogsEntry> orderByComparator) { 1757 return getPersistence() 1758 .findByC_U(companyId, userId, start, end, orderByComparator); 1759 } 1760 1761 /** 1762 * Returns an ordered range of all the blogs entries where companyId = ? and userId = ?. 1763 * 1764 * <p> 1765 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1766 * </p> 1767 * 1768 * @param companyId the company ID 1769 * @param userId the user ID 1770 * @param start the lower bound of the range of blogs entries 1771 * @param end the upper bound of the range of blogs entries (not inclusive) 1772 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1773 * @param retrieveFromCache whether to retrieve from the finder cache 1774 * @return the ordered range of matching blogs entries 1775 */ 1776 public static List<BlogsEntry> findByC_U(long companyId, long userId, 1777 int start, int end, OrderByComparator<BlogsEntry> orderByComparator, 1778 boolean retrieveFromCache) { 1779 return getPersistence() 1780 .findByC_U(companyId, userId, start, end, orderByComparator, 1781 retrieveFromCache); 1782 } 1783 1784 /** 1785 * Returns the first blogs entry in the ordered set where companyId = ? and userId = ?. 1786 * 1787 * @param companyId the company ID 1788 * @param userId the user ID 1789 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1790 * @return the first matching blogs entry 1791 * @throws NoSuchEntryException if a matching blogs entry could not be found 1792 */ 1793 public static BlogsEntry findByC_U_First(long companyId, long userId, 1794 OrderByComparator<BlogsEntry> orderByComparator) 1795 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 1796 return getPersistence() 1797 .findByC_U_First(companyId, userId, orderByComparator); 1798 } 1799 1800 /** 1801 * Returns the first blogs entry in the ordered set where companyId = ? and userId = ?. 1802 * 1803 * @param companyId the company ID 1804 * @param userId the user ID 1805 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1806 * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 1807 */ 1808 public static BlogsEntry fetchByC_U_First(long companyId, long userId, 1809 OrderByComparator<BlogsEntry> orderByComparator) { 1810 return getPersistence() 1811 .fetchByC_U_First(companyId, userId, orderByComparator); 1812 } 1813 1814 /** 1815 * Returns the last blogs entry in the ordered set where companyId = ? and userId = ?. 1816 * 1817 * @param companyId the company ID 1818 * @param userId the user ID 1819 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1820 * @return the last matching blogs entry 1821 * @throws NoSuchEntryException if a matching blogs entry could not be found 1822 */ 1823 public static BlogsEntry findByC_U_Last(long companyId, long userId, 1824 OrderByComparator<BlogsEntry> orderByComparator) 1825 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 1826 return getPersistence() 1827 .findByC_U_Last(companyId, userId, orderByComparator); 1828 } 1829 1830 /** 1831 * Returns the last blogs entry in the ordered set where companyId = ? and userId = ?. 1832 * 1833 * @param companyId the company ID 1834 * @param userId the user ID 1835 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1836 * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 1837 */ 1838 public static BlogsEntry fetchByC_U_Last(long companyId, long userId, 1839 OrderByComparator<BlogsEntry> orderByComparator) { 1840 return getPersistence() 1841 .fetchByC_U_Last(companyId, userId, orderByComparator); 1842 } 1843 1844 /** 1845 * Returns the blogs entries before and after the current blogs entry in the ordered set where companyId = ? and userId = ?. 1846 * 1847 * @param entryId the primary key of the current blogs entry 1848 * @param companyId the company ID 1849 * @param userId the user ID 1850 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1851 * @return the previous, current, and next blogs entry 1852 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 1853 */ 1854 public static BlogsEntry[] findByC_U_PrevAndNext(long entryId, 1855 long companyId, long userId, 1856 OrderByComparator<BlogsEntry> orderByComparator) 1857 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 1858 return getPersistence() 1859 .findByC_U_PrevAndNext(entryId, companyId, userId, 1860 orderByComparator); 1861 } 1862 1863 /** 1864 * Removes all the blogs entries where companyId = ? and userId = ? from the database. 1865 * 1866 * @param companyId the company ID 1867 * @param userId the user ID 1868 */ 1869 public static void removeByC_U(long companyId, long userId) { 1870 getPersistence().removeByC_U(companyId, userId); 1871 } 1872 1873 /** 1874 * Returns the number of blogs entries where companyId = ? and userId = ?. 1875 * 1876 * @param companyId the company ID 1877 * @param userId the user ID 1878 * @return the number of matching blogs entries 1879 */ 1880 public static int countByC_U(long companyId, long userId) { 1881 return getPersistence().countByC_U(companyId, userId); 1882 } 1883 1884 /** 1885 * Returns all the blogs entries where companyId = ? and displayDate < ?. 1886 * 1887 * @param companyId the company ID 1888 * @param displayDate the display date 1889 * @return the matching blogs entries 1890 */ 1891 public static List<BlogsEntry> findByC_LtD(long companyId, Date displayDate) { 1892 return getPersistence().findByC_LtD(companyId, displayDate); 1893 } 1894 1895 /** 1896 * Returns a range of all the blogs entries where companyId = ? and displayDate < ?. 1897 * 1898 * <p> 1899 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1900 * </p> 1901 * 1902 * @param companyId the company ID 1903 * @param displayDate the display date 1904 * @param start the lower bound of the range of blogs entries 1905 * @param end the upper bound of the range of blogs entries (not inclusive) 1906 * @return the range of matching blogs entries 1907 */ 1908 public static List<BlogsEntry> findByC_LtD(long companyId, 1909 Date displayDate, int start, int end) { 1910 return getPersistence().findByC_LtD(companyId, displayDate, start, end); 1911 } 1912 1913 /** 1914 * Returns an ordered range of all the blogs entries where companyId = ? and displayDate < ?. 1915 * 1916 * <p> 1917 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1918 * </p> 1919 * 1920 * @param companyId the company ID 1921 * @param displayDate the display date 1922 * @param start the lower bound of the range of blogs entries 1923 * @param end the upper bound of the range of blogs entries (not inclusive) 1924 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1925 * @return the ordered range of matching blogs entries 1926 */ 1927 public static List<BlogsEntry> findByC_LtD(long companyId, 1928 Date displayDate, int start, int end, 1929 OrderByComparator<BlogsEntry> orderByComparator) { 1930 return getPersistence() 1931 .findByC_LtD(companyId, displayDate, start, end, 1932 orderByComparator); 1933 } 1934 1935 /** 1936 * Returns an ordered range of all the blogs entries where companyId = ? and displayDate < ?. 1937 * 1938 * <p> 1939 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1940 * </p> 1941 * 1942 * @param companyId the company ID 1943 * @param displayDate the display date 1944 * @param start the lower bound of the range of blogs entries 1945 * @param end the upper bound of the range of blogs entries (not inclusive) 1946 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1947 * @param retrieveFromCache whether to retrieve from the finder cache 1948 * @return the ordered range of matching blogs entries 1949 */ 1950 public static List<BlogsEntry> findByC_LtD(long companyId, 1951 Date displayDate, int start, int end, 1952 OrderByComparator<BlogsEntry> orderByComparator, 1953 boolean retrieveFromCache) { 1954 return getPersistence() 1955 .findByC_LtD(companyId, displayDate, start, end, 1956 orderByComparator, retrieveFromCache); 1957 } 1958 1959 /** 1960 * Returns the first blogs entry in the ordered set where companyId = ? and displayDate < ?. 1961 * 1962 * @param companyId the company ID 1963 * @param displayDate the display date 1964 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1965 * @return the first matching blogs entry 1966 * @throws NoSuchEntryException if a matching blogs entry could not be found 1967 */ 1968 public static BlogsEntry findByC_LtD_First(long companyId, 1969 Date displayDate, OrderByComparator<BlogsEntry> orderByComparator) 1970 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 1971 return getPersistence() 1972 .findByC_LtD_First(companyId, displayDate, orderByComparator); 1973 } 1974 1975 /** 1976 * Returns the first blogs entry in the ordered set where companyId = ? and displayDate < ?. 1977 * 1978 * @param companyId the company ID 1979 * @param displayDate the display date 1980 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1981 * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 1982 */ 1983 public static BlogsEntry fetchByC_LtD_First(long companyId, 1984 Date displayDate, OrderByComparator<BlogsEntry> orderByComparator) { 1985 return getPersistence() 1986 .fetchByC_LtD_First(companyId, displayDate, orderByComparator); 1987 } 1988 1989 /** 1990 * Returns the last blogs entry in the ordered set where companyId = ? and displayDate < ?. 1991 * 1992 * @param companyId the company ID 1993 * @param displayDate the display date 1994 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1995 * @return the last matching blogs entry 1996 * @throws NoSuchEntryException if a matching blogs entry could not be found 1997 */ 1998 public static BlogsEntry findByC_LtD_Last(long companyId, Date displayDate, 1999 OrderByComparator<BlogsEntry> orderByComparator) 2000 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 2001 return getPersistence() 2002 .findByC_LtD_Last(companyId, displayDate, orderByComparator); 2003 } 2004 2005 /** 2006 * Returns the last blogs entry in the ordered set where companyId = ? and displayDate < ?. 2007 * 2008 * @param companyId the company ID 2009 * @param displayDate the display date 2010 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2011 * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 2012 */ 2013 public static BlogsEntry fetchByC_LtD_Last(long companyId, 2014 Date displayDate, OrderByComparator<BlogsEntry> orderByComparator) { 2015 return getPersistence() 2016 .fetchByC_LtD_Last(companyId, displayDate, orderByComparator); 2017 } 2018 2019 /** 2020 * Returns the blogs entries before and after the current blogs entry in the ordered set where companyId = ? and displayDate < ?. 2021 * 2022 * @param entryId the primary key of the current blogs entry 2023 * @param companyId the company ID 2024 * @param displayDate the display date 2025 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2026 * @return the previous, current, and next blogs entry 2027 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 2028 */ 2029 public static BlogsEntry[] findByC_LtD_PrevAndNext(long entryId, 2030 long companyId, Date displayDate, 2031 OrderByComparator<BlogsEntry> orderByComparator) 2032 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 2033 return getPersistence() 2034 .findByC_LtD_PrevAndNext(entryId, companyId, displayDate, 2035 orderByComparator); 2036 } 2037 2038 /** 2039 * Removes all the blogs entries where companyId = ? and displayDate < ? from the database. 2040 * 2041 * @param companyId the company ID 2042 * @param displayDate the display date 2043 */ 2044 public static void removeByC_LtD(long companyId, Date displayDate) { 2045 getPersistence().removeByC_LtD(companyId, displayDate); 2046 } 2047 2048 /** 2049 * Returns the number of blogs entries where companyId = ? and displayDate < ?. 2050 * 2051 * @param companyId the company ID 2052 * @param displayDate the display date 2053 * @return the number of matching blogs entries 2054 */ 2055 public static int countByC_LtD(long companyId, Date displayDate) { 2056 return getPersistence().countByC_LtD(companyId, displayDate); 2057 } 2058 2059 /** 2060 * Returns all the blogs entries where companyId = ? and status = ?. 2061 * 2062 * @param companyId the company ID 2063 * @param status the status 2064 * @return the matching blogs entries 2065 */ 2066 public static List<BlogsEntry> findByC_S(long companyId, int status) { 2067 return getPersistence().findByC_S(companyId, status); 2068 } 2069 2070 /** 2071 * Returns a range of all the blogs entries where companyId = ? and status = ?. 2072 * 2073 * <p> 2074 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2075 * </p> 2076 * 2077 * @param companyId the company ID 2078 * @param status the status 2079 * @param start the lower bound of the range of blogs entries 2080 * @param end the upper bound of the range of blogs entries (not inclusive) 2081 * @return the range of matching blogs entries 2082 */ 2083 public static List<BlogsEntry> findByC_S(long companyId, int status, 2084 int start, int end) { 2085 return getPersistence().findByC_S(companyId, status, start, end); 2086 } 2087 2088 /** 2089 * Returns an ordered range of all the blogs entries where companyId = ? and status = ?. 2090 * 2091 * <p> 2092 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2093 * </p> 2094 * 2095 * @param companyId the company ID 2096 * @param status the status 2097 * @param start the lower bound of the range of blogs entries 2098 * @param end the upper bound of the range of blogs entries (not inclusive) 2099 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2100 * @return the ordered range of matching blogs entries 2101 */ 2102 public static List<BlogsEntry> findByC_S(long companyId, int status, 2103 int start, int end, OrderByComparator<BlogsEntry> orderByComparator) { 2104 return getPersistence() 2105 .findByC_S(companyId, status, start, end, orderByComparator); 2106 } 2107 2108 /** 2109 * Returns an ordered range of all the blogs entries where companyId = ? and status = ?. 2110 * 2111 * <p> 2112 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2113 * </p> 2114 * 2115 * @param companyId the company ID 2116 * @param status the status 2117 * @param start the lower bound of the range of blogs entries 2118 * @param end the upper bound of the range of blogs entries (not inclusive) 2119 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2120 * @param retrieveFromCache whether to retrieve from the finder cache 2121 * @return the ordered range of matching blogs entries 2122 */ 2123 public static List<BlogsEntry> findByC_S(long companyId, int status, 2124 int start, int end, OrderByComparator<BlogsEntry> orderByComparator, 2125 boolean retrieveFromCache) { 2126 return getPersistence() 2127 .findByC_S(companyId, status, start, end, orderByComparator, 2128 retrieveFromCache); 2129 } 2130 2131 /** 2132 * Returns the first blogs entry in the ordered set where companyId = ? and status = ?. 2133 * 2134 * @param companyId the company ID 2135 * @param status the status 2136 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2137 * @return the first matching blogs entry 2138 * @throws NoSuchEntryException if a matching blogs entry could not be found 2139 */ 2140 public static BlogsEntry findByC_S_First(long companyId, int status, 2141 OrderByComparator<BlogsEntry> orderByComparator) 2142 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 2143 return getPersistence() 2144 .findByC_S_First(companyId, status, orderByComparator); 2145 } 2146 2147 /** 2148 * Returns the first blogs entry in the ordered set where companyId = ? and status = ?. 2149 * 2150 * @param companyId the company ID 2151 * @param status the status 2152 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2153 * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 2154 */ 2155 public static BlogsEntry fetchByC_S_First(long companyId, int status, 2156 OrderByComparator<BlogsEntry> orderByComparator) { 2157 return getPersistence() 2158 .fetchByC_S_First(companyId, status, orderByComparator); 2159 } 2160 2161 /** 2162 * Returns the last blogs entry in the ordered set where companyId = ? and status = ?. 2163 * 2164 * @param companyId the company ID 2165 * @param status the status 2166 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2167 * @return the last matching blogs entry 2168 * @throws NoSuchEntryException if a matching blogs entry could not be found 2169 */ 2170 public static BlogsEntry findByC_S_Last(long companyId, int status, 2171 OrderByComparator<BlogsEntry> orderByComparator) 2172 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 2173 return getPersistence() 2174 .findByC_S_Last(companyId, status, orderByComparator); 2175 } 2176 2177 /** 2178 * Returns the last blogs entry in the ordered set where companyId = ? and status = ?. 2179 * 2180 * @param companyId the company ID 2181 * @param status the status 2182 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2183 * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 2184 */ 2185 public static BlogsEntry fetchByC_S_Last(long companyId, int status, 2186 OrderByComparator<BlogsEntry> orderByComparator) { 2187 return getPersistence() 2188 .fetchByC_S_Last(companyId, status, orderByComparator); 2189 } 2190 2191 /** 2192 * Returns the blogs entries before and after the current blogs entry in the ordered set where companyId = ? and status = ?. 2193 * 2194 * @param entryId the primary key of the current blogs entry 2195 * @param companyId the company ID 2196 * @param status the status 2197 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2198 * @return the previous, current, and next blogs entry 2199 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 2200 */ 2201 public static BlogsEntry[] findByC_S_PrevAndNext(long entryId, 2202 long companyId, int status, 2203 OrderByComparator<BlogsEntry> orderByComparator) 2204 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 2205 return getPersistence() 2206 .findByC_S_PrevAndNext(entryId, companyId, status, 2207 orderByComparator); 2208 } 2209 2210 /** 2211 * Removes all the blogs entries where companyId = ? and status = ? from the database. 2212 * 2213 * @param companyId the company ID 2214 * @param status the status 2215 */ 2216 public static void removeByC_S(long companyId, int status) { 2217 getPersistence().removeByC_S(companyId, status); 2218 } 2219 2220 /** 2221 * Returns the number of blogs entries where companyId = ? and status = ?. 2222 * 2223 * @param companyId the company ID 2224 * @param status the status 2225 * @return the number of matching blogs entries 2226 */ 2227 public static int countByC_S(long companyId, int status) { 2228 return getPersistence().countByC_S(companyId, status); 2229 } 2230 2231 /** 2232 * Returns all the blogs entries where companyId = ? and status ≠ ?. 2233 * 2234 * @param companyId the company ID 2235 * @param status the status 2236 * @return the matching blogs entries 2237 */ 2238 public static List<BlogsEntry> findByC_NotS(long companyId, int status) { 2239 return getPersistence().findByC_NotS(companyId, status); 2240 } 2241 2242 /** 2243 * Returns a range of all the blogs entries where companyId = ? and status ≠ ?. 2244 * 2245 * <p> 2246 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2247 * </p> 2248 * 2249 * @param companyId the company ID 2250 * @param status the status 2251 * @param start the lower bound of the range of blogs entries 2252 * @param end the upper bound of the range of blogs entries (not inclusive) 2253 * @return the range of matching blogs entries 2254 */ 2255 public static List<BlogsEntry> findByC_NotS(long companyId, int status, 2256 int start, int end) { 2257 return getPersistence().findByC_NotS(companyId, status, start, end); 2258 } 2259 2260 /** 2261 * Returns an ordered range of all the blogs entries where companyId = ? and status ≠ ?. 2262 * 2263 * <p> 2264 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2265 * </p> 2266 * 2267 * @param companyId the company ID 2268 * @param status the status 2269 * @param start the lower bound of the range of blogs entries 2270 * @param end the upper bound of the range of blogs entries (not inclusive) 2271 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2272 * @return the ordered range of matching blogs entries 2273 */ 2274 public static List<BlogsEntry> findByC_NotS(long companyId, int status, 2275 int start, int end, OrderByComparator<BlogsEntry> orderByComparator) { 2276 return getPersistence() 2277 .findByC_NotS(companyId, status, start, end, 2278 orderByComparator); 2279 } 2280 2281 /** 2282 * Returns an ordered range of all the blogs entries where companyId = ? and status ≠ ?. 2283 * 2284 * <p> 2285 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2286 * </p> 2287 * 2288 * @param companyId the company ID 2289 * @param status the status 2290 * @param start the lower bound of the range of blogs entries 2291 * @param end the upper bound of the range of blogs entries (not inclusive) 2292 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2293 * @param retrieveFromCache whether to retrieve from the finder cache 2294 * @return the ordered range of matching blogs entries 2295 */ 2296 public static List<BlogsEntry> findByC_NotS(long companyId, int status, 2297 int start, int end, OrderByComparator<BlogsEntry> orderByComparator, 2298 boolean retrieveFromCache) { 2299 return getPersistence() 2300 .findByC_NotS(companyId, status, start, end, 2301 orderByComparator, retrieveFromCache); 2302 } 2303 2304 /** 2305 * Returns the first blogs entry in the ordered set where companyId = ? and status ≠ ?. 2306 * 2307 * @param companyId the company ID 2308 * @param status the status 2309 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2310 * @return the first matching blogs entry 2311 * @throws NoSuchEntryException if a matching blogs entry could not be found 2312 */ 2313 public static BlogsEntry findByC_NotS_First(long companyId, int status, 2314 OrderByComparator<BlogsEntry> orderByComparator) 2315 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 2316 return getPersistence() 2317 .findByC_NotS_First(companyId, status, orderByComparator); 2318 } 2319 2320 /** 2321 * Returns the first blogs entry in the ordered set where companyId = ? and status ≠ ?. 2322 * 2323 * @param companyId the company ID 2324 * @param status the status 2325 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2326 * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 2327 */ 2328 public static BlogsEntry fetchByC_NotS_First(long companyId, int status, 2329 OrderByComparator<BlogsEntry> orderByComparator) { 2330 return getPersistence() 2331 .fetchByC_NotS_First(companyId, status, orderByComparator); 2332 } 2333 2334 /** 2335 * Returns the last blogs entry in the ordered set where companyId = ? and status ≠ ?. 2336 * 2337 * @param companyId the company ID 2338 * @param status the status 2339 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2340 * @return the last matching blogs entry 2341 * @throws NoSuchEntryException if a matching blogs entry could not be found 2342 */ 2343 public static BlogsEntry findByC_NotS_Last(long companyId, int status, 2344 OrderByComparator<BlogsEntry> orderByComparator) 2345 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 2346 return getPersistence() 2347 .findByC_NotS_Last(companyId, status, orderByComparator); 2348 } 2349 2350 /** 2351 * Returns the last blogs entry in the ordered set where companyId = ? and status ≠ ?. 2352 * 2353 * @param companyId the company ID 2354 * @param status the status 2355 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2356 * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 2357 */ 2358 public static BlogsEntry fetchByC_NotS_Last(long companyId, int status, 2359 OrderByComparator<BlogsEntry> orderByComparator) { 2360 return getPersistence() 2361 .fetchByC_NotS_Last(companyId, status, orderByComparator); 2362 } 2363 2364 /** 2365 * Returns the blogs entries before and after the current blogs entry in the ordered set where companyId = ? and status ≠ ?. 2366 * 2367 * @param entryId the primary key of the current blogs entry 2368 * @param companyId the company ID 2369 * @param status the status 2370 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2371 * @return the previous, current, and next blogs entry 2372 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 2373 */ 2374 public static BlogsEntry[] findByC_NotS_PrevAndNext(long entryId, 2375 long companyId, int status, 2376 OrderByComparator<BlogsEntry> orderByComparator) 2377 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 2378 return getPersistence() 2379 .findByC_NotS_PrevAndNext(entryId, companyId, status, 2380 orderByComparator); 2381 } 2382 2383 /** 2384 * Removes all the blogs entries where companyId = ? and status ≠ ? from the database. 2385 * 2386 * @param companyId the company ID 2387 * @param status the status 2388 */ 2389 public static void removeByC_NotS(long companyId, int status) { 2390 getPersistence().removeByC_NotS(companyId, status); 2391 } 2392 2393 /** 2394 * Returns the number of blogs entries where companyId = ? and status ≠ ?. 2395 * 2396 * @param companyId the company ID 2397 * @param status the status 2398 * @return the number of matching blogs entries 2399 */ 2400 public static int countByC_NotS(long companyId, int status) { 2401 return getPersistence().countByC_NotS(companyId, status); 2402 } 2403 2404 /** 2405 * Returns all the blogs entries where displayDate < ? and status = ?. 2406 * 2407 * @param displayDate the display date 2408 * @param status the status 2409 * @return the matching blogs entries 2410 */ 2411 public static List<BlogsEntry> findByLtD_S(Date displayDate, int status) { 2412 return getPersistence().findByLtD_S(displayDate, status); 2413 } 2414 2415 /** 2416 * Returns a range of all the blogs entries where displayDate < ? and status = ?. 2417 * 2418 * <p> 2419 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2420 * </p> 2421 * 2422 * @param displayDate the display date 2423 * @param status the status 2424 * @param start the lower bound of the range of blogs entries 2425 * @param end the upper bound of the range of blogs entries (not inclusive) 2426 * @return the range of matching blogs entries 2427 */ 2428 public static List<BlogsEntry> findByLtD_S(Date displayDate, int status, 2429 int start, int end) { 2430 return getPersistence().findByLtD_S(displayDate, status, start, end); 2431 } 2432 2433 /** 2434 * Returns an ordered range of all the blogs entries where displayDate < ? and status = ?. 2435 * 2436 * <p> 2437 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2438 * </p> 2439 * 2440 * @param displayDate the display date 2441 * @param status the status 2442 * @param start the lower bound of the range of blogs entries 2443 * @param end the upper bound of the range of blogs entries (not inclusive) 2444 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2445 * @return the ordered range of matching blogs entries 2446 */ 2447 public static List<BlogsEntry> findByLtD_S(Date displayDate, int status, 2448 int start, int end, OrderByComparator<BlogsEntry> orderByComparator) { 2449 return getPersistence() 2450 .findByLtD_S(displayDate, status, start, end, 2451 orderByComparator); 2452 } 2453 2454 /** 2455 * Returns an ordered range of all the blogs entries where displayDate < ? and status = ?. 2456 * 2457 * <p> 2458 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2459 * </p> 2460 * 2461 * @param displayDate the display date 2462 * @param status the status 2463 * @param start the lower bound of the range of blogs entries 2464 * @param end the upper bound of the range of blogs entries (not inclusive) 2465 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2466 * @param retrieveFromCache whether to retrieve from the finder cache 2467 * @return the ordered range of matching blogs entries 2468 */ 2469 public static List<BlogsEntry> findByLtD_S(Date displayDate, int status, 2470 int start, int end, OrderByComparator<BlogsEntry> orderByComparator, 2471 boolean retrieveFromCache) { 2472 return getPersistence() 2473 .findByLtD_S(displayDate, status, start, end, 2474 orderByComparator, retrieveFromCache); 2475 } 2476 2477 /** 2478 * Returns the first blogs entry in the ordered set where displayDate < ? and status = ?. 2479 * 2480 * @param displayDate the display date 2481 * @param status the status 2482 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2483 * @return the first matching blogs entry 2484 * @throws NoSuchEntryException if a matching blogs entry could not be found 2485 */ 2486 public static BlogsEntry findByLtD_S_First(Date displayDate, int status, 2487 OrderByComparator<BlogsEntry> orderByComparator) 2488 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 2489 return getPersistence() 2490 .findByLtD_S_First(displayDate, status, orderByComparator); 2491 } 2492 2493 /** 2494 * Returns the first blogs entry in the ordered set where displayDate < ? and status = ?. 2495 * 2496 * @param displayDate the display date 2497 * @param status the status 2498 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2499 * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 2500 */ 2501 public static BlogsEntry fetchByLtD_S_First(Date displayDate, int status, 2502 OrderByComparator<BlogsEntry> orderByComparator) { 2503 return getPersistence() 2504 .fetchByLtD_S_First(displayDate, status, orderByComparator); 2505 } 2506 2507 /** 2508 * Returns the last blogs entry in the ordered set where displayDate < ? and status = ?. 2509 * 2510 * @param displayDate the display date 2511 * @param status the status 2512 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2513 * @return the last matching blogs entry 2514 * @throws NoSuchEntryException if a matching blogs entry could not be found 2515 */ 2516 public static BlogsEntry findByLtD_S_Last(Date displayDate, int status, 2517 OrderByComparator<BlogsEntry> orderByComparator) 2518 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 2519 return getPersistence() 2520 .findByLtD_S_Last(displayDate, status, orderByComparator); 2521 } 2522 2523 /** 2524 * Returns the last blogs entry in the ordered set where displayDate < ? and status = ?. 2525 * 2526 * @param displayDate the display date 2527 * @param status the status 2528 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2529 * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 2530 */ 2531 public static BlogsEntry fetchByLtD_S_Last(Date displayDate, int status, 2532 OrderByComparator<BlogsEntry> orderByComparator) { 2533 return getPersistence() 2534 .fetchByLtD_S_Last(displayDate, status, orderByComparator); 2535 } 2536 2537 /** 2538 * Returns the blogs entries before and after the current blogs entry in the ordered set where displayDate < ? and status = ?. 2539 * 2540 * @param entryId the primary key of the current blogs entry 2541 * @param displayDate the display date 2542 * @param status the status 2543 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2544 * @return the previous, current, and next blogs entry 2545 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 2546 */ 2547 public static BlogsEntry[] findByLtD_S_PrevAndNext(long entryId, 2548 Date displayDate, int status, 2549 OrderByComparator<BlogsEntry> orderByComparator) 2550 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 2551 return getPersistence() 2552 .findByLtD_S_PrevAndNext(entryId, displayDate, status, 2553 orderByComparator); 2554 } 2555 2556 /** 2557 * Removes all the blogs entries where displayDate < ? and status = ? from the database. 2558 * 2559 * @param displayDate the display date 2560 * @param status the status 2561 */ 2562 public static void removeByLtD_S(Date displayDate, int status) { 2563 getPersistence().removeByLtD_S(displayDate, status); 2564 } 2565 2566 /** 2567 * Returns the number of blogs entries where displayDate < ? and status = ?. 2568 * 2569 * @param displayDate the display date 2570 * @param status the status 2571 * @return the number of matching blogs entries 2572 */ 2573 public static int countByLtD_S(Date displayDate, int status) { 2574 return getPersistence().countByLtD_S(displayDate, status); 2575 } 2576 2577 /** 2578 * Returns all the blogs entries where groupId = ? and userId = ? and displayDate < ?. 2579 * 2580 * @param groupId the group ID 2581 * @param userId the user ID 2582 * @param displayDate the display date 2583 * @return the matching blogs entries 2584 */ 2585 public static List<BlogsEntry> findByG_U_LtD(long groupId, long userId, 2586 Date displayDate) { 2587 return getPersistence().findByG_U_LtD(groupId, userId, displayDate); 2588 } 2589 2590 /** 2591 * Returns a range of all the blogs entries where groupId = ? and userId = ? and displayDate < ?. 2592 * 2593 * <p> 2594 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2595 * </p> 2596 * 2597 * @param groupId the group ID 2598 * @param userId the user ID 2599 * @param displayDate the display date 2600 * @param start the lower bound of the range of blogs entries 2601 * @param end the upper bound of the range of blogs entries (not inclusive) 2602 * @return the range of matching blogs entries 2603 */ 2604 public static List<BlogsEntry> findByG_U_LtD(long groupId, long userId, 2605 Date displayDate, int start, int end) { 2606 return getPersistence() 2607 .findByG_U_LtD(groupId, userId, displayDate, start, end); 2608 } 2609 2610 /** 2611 * Returns an ordered range of all the blogs entries where groupId = ? and userId = ? and displayDate < ?. 2612 * 2613 * <p> 2614 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2615 * </p> 2616 * 2617 * @param groupId the group ID 2618 * @param userId the user ID 2619 * @param displayDate the display date 2620 * @param start the lower bound of the range of blogs entries 2621 * @param end the upper bound of the range of blogs entries (not inclusive) 2622 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2623 * @return the ordered range of matching blogs entries 2624 */ 2625 public static List<BlogsEntry> findByG_U_LtD(long groupId, long userId, 2626 Date displayDate, int start, int end, 2627 OrderByComparator<BlogsEntry> orderByComparator) { 2628 return getPersistence() 2629 .findByG_U_LtD(groupId, userId, displayDate, start, end, 2630 orderByComparator); 2631 } 2632 2633 /** 2634 * Returns an ordered range of all the blogs entries where groupId = ? and userId = ? and displayDate < ?. 2635 * 2636 * <p> 2637 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2638 * </p> 2639 * 2640 * @param groupId the group ID 2641 * @param userId the user ID 2642 * @param displayDate the display date 2643 * @param start the lower bound of the range of blogs entries 2644 * @param end the upper bound of the range of blogs entries (not inclusive) 2645 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2646 * @param retrieveFromCache whether to retrieve from the finder cache 2647 * @return the ordered range of matching blogs entries 2648 */ 2649 public static List<BlogsEntry> findByG_U_LtD(long groupId, long userId, 2650 Date displayDate, int start, int end, 2651 OrderByComparator<BlogsEntry> orderByComparator, 2652 boolean retrieveFromCache) { 2653 return getPersistence() 2654 .findByG_U_LtD(groupId, userId, displayDate, start, end, 2655 orderByComparator, retrieveFromCache); 2656 } 2657 2658 /** 2659 * Returns the first blogs entry in the ordered set where groupId = ? and userId = ? and displayDate < ?. 2660 * 2661 * @param groupId the group ID 2662 * @param userId the user ID 2663 * @param displayDate the display date 2664 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2665 * @return the first matching blogs entry 2666 * @throws NoSuchEntryException if a matching blogs entry could not be found 2667 */ 2668 public static BlogsEntry findByG_U_LtD_First(long groupId, long userId, 2669 Date displayDate, OrderByComparator<BlogsEntry> orderByComparator) 2670 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 2671 return getPersistence() 2672 .findByG_U_LtD_First(groupId, userId, displayDate, 2673 orderByComparator); 2674 } 2675 2676 /** 2677 * Returns the first blogs entry in the ordered set where groupId = ? and userId = ? and displayDate < ?. 2678 * 2679 * @param groupId the group ID 2680 * @param userId the user ID 2681 * @param displayDate the display date 2682 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2683 * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 2684 */ 2685 public static BlogsEntry fetchByG_U_LtD_First(long groupId, long userId, 2686 Date displayDate, OrderByComparator<BlogsEntry> orderByComparator) { 2687 return getPersistence() 2688 .fetchByG_U_LtD_First(groupId, userId, displayDate, 2689 orderByComparator); 2690 } 2691 2692 /** 2693 * Returns the last blogs entry in the ordered set where groupId = ? and userId = ? and displayDate < ?. 2694 * 2695 * @param groupId the group ID 2696 * @param userId the user ID 2697 * @param displayDate the display date 2698 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2699 * @return the last matching blogs entry 2700 * @throws NoSuchEntryException if a matching blogs entry could not be found 2701 */ 2702 public static BlogsEntry findByG_U_LtD_Last(long groupId, long userId, 2703 Date displayDate, OrderByComparator<BlogsEntry> orderByComparator) 2704 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 2705 return getPersistence() 2706 .findByG_U_LtD_Last(groupId, userId, displayDate, 2707 orderByComparator); 2708 } 2709 2710 /** 2711 * Returns the last blogs entry in the ordered set where groupId = ? and userId = ? and displayDate < ?. 2712 * 2713 * @param groupId the group ID 2714 * @param userId the user ID 2715 * @param displayDate the display date 2716 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2717 * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 2718 */ 2719 public static BlogsEntry fetchByG_U_LtD_Last(long groupId, long userId, 2720 Date displayDate, OrderByComparator<BlogsEntry> orderByComparator) { 2721 return getPersistence() 2722 .fetchByG_U_LtD_Last(groupId, userId, displayDate, 2723 orderByComparator); 2724 } 2725 2726 /** 2727 * Returns the blogs entries before and after the current blogs entry in the ordered set where groupId = ? and userId = ? and displayDate < ?. 2728 * 2729 * @param entryId the primary key of the current blogs entry 2730 * @param groupId the group ID 2731 * @param userId the user ID 2732 * @param displayDate the display date 2733 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2734 * @return the previous, current, and next blogs entry 2735 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 2736 */ 2737 public static BlogsEntry[] findByG_U_LtD_PrevAndNext(long entryId, 2738 long groupId, long userId, Date displayDate, 2739 OrderByComparator<BlogsEntry> orderByComparator) 2740 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 2741 return getPersistence() 2742 .findByG_U_LtD_PrevAndNext(entryId, groupId, userId, 2743 displayDate, orderByComparator); 2744 } 2745 2746 /** 2747 * Returns all the blogs entries that the user has permission to view where groupId = ? and userId = ? and displayDate < ?. 2748 * 2749 * @param groupId the group ID 2750 * @param userId the user ID 2751 * @param displayDate the display date 2752 * @return the matching blogs entries that the user has permission to view 2753 */ 2754 public static List<BlogsEntry> filterFindByG_U_LtD(long groupId, 2755 long userId, Date displayDate) { 2756 return getPersistence().filterFindByG_U_LtD(groupId, userId, displayDate); 2757 } 2758 2759 /** 2760 * Returns a range of all the blogs entries that the user has permission to view where groupId = ? and userId = ? and displayDate < ?. 2761 * 2762 * <p> 2763 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2764 * </p> 2765 * 2766 * @param groupId the group ID 2767 * @param userId the user ID 2768 * @param displayDate the display date 2769 * @param start the lower bound of the range of blogs entries 2770 * @param end the upper bound of the range of blogs entries (not inclusive) 2771 * @return the range of matching blogs entries that the user has permission to view 2772 */ 2773 public static List<BlogsEntry> filterFindByG_U_LtD(long groupId, 2774 long userId, Date displayDate, int start, int end) { 2775 return getPersistence() 2776 .filterFindByG_U_LtD(groupId, userId, displayDate, start, end); 2777 } 2778 2779 /** 2780 * Returns an ordered range of all the blogs entries that the user has permissions to view where groupId = ? and userId = ? and displayDate < ?. 2781 * 2782 * <p> 2783 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2784 * </p> 2785 * 2786 * @param groupId the group ID 2787 * @param userId the user ID 2788 * @param displayDate the display date 2789 * @param start the lower bound of the range of blogs entries 2790 * @param end the upper bound of the range of blogs entries (not inclusive) 2791 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2792 * @return the ordered range of matching blogs entries that the user has permission to view 2793 */ 2794 public static List<BlogsEntry> filterFindByG_U_LtD(long groupId, 2795 long userId, Date displayDate, int start, int end, 2796 OrderByComparator<BlogsEntry> orderByComparator) { 2797 return getPersistence() 2798 .filterFindByG_U_LtD(groupId, userId, displayDate, start, 2799 end, orderByComparator); 2800 } 2801 2802 /** 2803 * 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 < ?. 2804 * 2805 * @param entryId the primary key of the current blogs entry 2806 * @param groupId the group ID 2807 * @param userId the user ID 2808 * @param displayDate the display date 2809 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2810 * @return the previous, current, and next blogs entry 2811 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 2812 */ 2813 public static BlogsEntry[] filterFindByG_U_LtD_PrevAndNext(long entryId, 2814 long groupId, long userId, Date displayDate, 2815 OrderByComparator<BlogsEntry> orderByComparator) 2816 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 2817 return getPersistence() 2818 .filterFindByG_U_LtD_PrevAndNext(entryId, groupId, userId, 2819 displayDate, orderByComparator); 2820 } 2821 2822 /** 2823 * Removes all the blogs entries where groupId = ? and userId = ? and displayDate < ? from the database. 2824 * 2825 * @param groupId the group ID 2826 * @param userId the user ID 2827 * @param displayDate the display date 2828 */ 2829 public static void removeByG_U_LtD(long groupId, long userId, 2830 Date displayDate) { 2831 getPersistence().removeByG_U_LtD(groupId, userId, displayDate); 2832 } 2833 2834 /** 2835 * Returns the number of blogs entries where groupId = ? and userId = ? and displayDate < ?. 2836 * 2837 * @param groupId the group ID 2838 * @param userId the user ID 2839 * @param displayDate the display date 2840 * @return the number of matching blogs entries 2841 */ 2842 public static int countByG_U_LtD(long groupId, long userId, Date displayDate) { 2843 return getPersistence().countByG_U_LtD(groupId, userId, displayDate); 2844 } 2845 2846 /** 2847 * Returns the number of blogs entries that the user has permission to view where groupId = ? and userId = ? and displayDate < ?. 2848 * 2849 * @param groupId the group ID 2850 * @param userId the user ID 2851 * @param displayDate the display date 2852 * @return the number of matching blogs entries that the user has permission to view 2853 */ 2854 public static int filterCountByG_U_LtD(long groupId, long userId, 2855 Date displayDate) { 2856 return getPersistence() 2857 .filterCountByG_U_LtD(groupId, userId, displayDate); 2858 } 2859 2860 /** 2861 * Returns all the blogs entries where groupId = ? and userId = ? and status = ?. 2862 * 2863 * @param groupId the group ID 2864 * @param userId the user ID 2865 * @param status the status 2866 * @return the matching blogs entries 2867 */ 2868 public static List<BlogsEntry> findByG_U_S(long groupId, long userId, 2869 int status) { 2870 return getPersistence().findByG_U_S(groupId, userId, status); 2871 } 2872 2873 /** 2874 * Returns a range of all the blogs entries where groupId = ? and userId = ? and status = ?. 2875 * 2876 * <p> 2877 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2878 * </p> 2879 * 2880 * @param groupId the group ID 2881 * @param userId the user ID 2882 * @param status the status 2883 * @param start the lower bound of the range of blogs entries 2884 * @param end the upper bound of the range of blogs entries (not inclusive) 2885 * @return the range of matching blogs entries 2886 */ 2887 public static List<BlogsEntry> findByG_U_S(long groupId, long userId, 2888 int status, int start, int end) { 2889 return getPersistence().findByG_U_S(groupId, userId, status, start, end); 2890 } 2891 2892 /** 2893 * Returns an ordered range of all the blogs entries where groupId = ? and userId = ? and status = ?. 2894 * 2895 * <p> 2896 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2897 * </p> 2898 * 2899 * @param groupId the group ID 2900 * @param userId the user ID 2901 * @param status the status 2902 * @param start the lower bound of the range of blogs entries 2903 * @param end the upper bound of the range of blogs entries (not inclusive) 2904 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2905 * @return the ordered range of matching blogs entries 2906 */ 2907 public static List<BlogsEntry> findByG_U_S(long groupId, long userId, 2908 int status, int start, int end, 2909 OrderByComparator<BlogsEntry> orderByComparator) { 2910 return getPersistence() 2911 .findByG_U_S(groupId, userId, status, start, end, 2912 orderByComparator); 2913 } 2914 2915 /** 2916 * Returns an ordered range of all the blogs entries where groupId = ? and userId = ? and status = ?. 2917 * 2918 * <p> 2919 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2920 * </p> 2921 * 2922 * @param groupId the group ID 2923 * @param userId the user ID 2924 * @param status the status 2925 * @param start the lower bound of the range of blogs entries 2926 * @param end the upper bound of the range of blogs entries (not inclusive) 2927 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2928 * @param retrieveFromCache whether to retrieve from the finder cache 2929 * @return the ordered range of matching blogs entries 2930 */ 2931 public static List<BlogsEntry> findByG_U_S(long groupId, long userId, 2932 int status, int start, int end, 2933 OrderByComparator<BlogsEntry> orderByComparator, 2934 boolean retrieveFromCache) { 2935 return getPersistence() 2936 .findByG_U_S(groupId, userId, status, start, end, 2937 orderByComparator, retrieveFromCache); 2938 } 2939 2940 /** 2941 * Returns the first blogs entry in the ordered set where groupId = ? and userId = ? and status = ?. 2942 * 2943 * @param groupId the group ID 2944 * @param userId the user ID 2945 * @param status the status 2946 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2947 * @return the first matching blogs entry 2948 * @throws NoSuchEntryException if a matching blogs entry could not be found 2949 */ 2950 public static BlogsEntry findByG_U_S_First(long groupId, long userId, 2951 int status, OrderByComparator<BlogsEntry> orderByComparator) 2952 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 2953 return getPersistence() 2954 .findByG_U_S_First(groupId, userId, status, orderByComparator); 2955 } 2956 2957 /** 2958 * Returns the first blogs entry in the ordered set where groupId = ? and userId = ? and status = ?. 2959 * 2960 * @param groupId the group ID 2961 * @param userId the user ID 2962 * @param status the status 2963 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2964 * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 2965 */ 2966 public static BlogsEntry fetchByG_U_S_First(long groupId, long userId, 2967 int status, OrderByComparator<BlogsEntry> orderByComparator) { 2968 return getPersistence() 2969 .fetchByG_U_S_First(groupId, userId, status, 2970 orderByComparator); 2971 } 2972 2973 /** 2974 * Returns the last blogs entry in the ordered set where groupId = ? and userId = ? and status = ?. 2975 * 2976 * @param groupId the group ID 2977 * @param userId the user ID 2978 * @param status the status 2979 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2980 * @return the last matching blogs entry 2981 * @throws NoSuchEntryException if a matching blogs entry could not be found 2982 */ 2983 public static BlogsEntry findByG_U_S_Last(long groupId, long userId, 2984 int status, OrderByComparator<BlogsEntry> orderByComparator) 2985 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 2986 return getPersistence() 2987 .findByG_U_S_Last(groupId, userId, status, orderByComparator); 2988 } 2989 2990 /** 2991 * Returns the last blogs entry in the ordered set where groupId = ? and userId = ? and status = ?. 2992 * 2993 * @param groupId the group ID 2994 * @param userId the user ID 2995 * @param status the status 2996 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2997 * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 2998 */ 2999 public static BlogsEntry fetchByG_U_S_Last(long groupId, long userId, 3000 int status, OrderByComparator<BlogsEntry> orderByComparator) { 3001 return getPersistence() 3002 .fetchByG_U_S_Last(groupId, userId, status, orderByComparator); 3003 } 3004 3005 /** 3006 * Returns the blogs entries before and after the current blogs entry in the ordered set where groupId = ? and userId = ? and status = ?. 3007 * 3008 * @param entryId the primary key of the current blogs entry 3009 * @param groupId the group ID 3010 * @param userId the user ID 3011 * @param status the status 3012 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3013 * @return the previous, current, and next blogs entry 3014 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 3015 */ 3016 public static BlogsEntry[] findByG_U_S_PrevAndNext(long entryId, 3017 long groupId, long userId, int status, 3018 OrderByComparator<BlogsEntry> orderByComparator) 3019 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 3020 return getPersistence() 3021 .findByG_U_S_PrevAndNext(entryId, groupId, userId, status, 3022 orderByComparator); 3023 } 3024 3025 /** 3026 * Returns all the blogs entries that the user has permission to view where groupId = ? and userId = ? and status = ?. 3027 * 3028 * @param groupId the group ID 3029 * @param userId the user ID 3030 * @param status the status 3031 * @return the matching blogs entries that the user has permission to view 3032 */ 3033 public static List<BlogsEntry> filterFindByG_U_S(long groupId, long userId, 3034 int status) { 3035 return getPersistence().filterFindByG_U_S(groupId, userId, status); 3036 } 3037 3038 /** 3039 * Returns a range of all the blogs entries that the user has permission to view where groupId = ? and userId = ? and status = ?. 3040 * 3041 * <p> 3042 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3043 * </p> 3044 * 3045 * @param groupId the group ID 3046 * @param userId the user ID 3047 * @param status the status 3048 * @param start the lower bound of the range of blogs entries 3049 * @param end the upper bound of the range of blogs entries (not inclusive) 3050 * @return the range of matching blogs entries that the user has permission to view 3051 */ 3052 public static List<BlogsEntry> filterFindByG_U_S(long groupId, long userId, 3053 int status, int start, int end) { 3054 return getPersistence() 3055 .filterFindByG_U_S(groupId, userId, status, start, end); 3056 } 3057 3058 /** 3059 * Returns an ordered range of all the blogs entries that the user has permissions to view where groupId = ? and userId = ? and status = ?. 3060 * 3061 * <p> 3062 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3063 * </p> 3064 * 3065 * @param groupId the group ID 3066 * @param userId the user ID 3067 * @param status the status 3068 * @param start the lower bound of the range of blogs entries 3069 * @param end the upper bound of the range of blogs entries (not inclusive) 3070 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3071 * @return the ordered range of matching blogs entries that the user has permission to view 3072 */ 3073 public static List<BlogsEntry> filterFindByG_U_S(long groupId, long userId, 3074 int status, int start, int end, 3075 OrderByComparator<BlogsEntry> orderByComparator) { 3076 return getPersistence() 3077 .filterFindByG_U_S(groupId, userId, status, start, end, 3078 orderByComparator); 3079 } 3080 3081 /** 3082 * 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 = ?. 3083 * 3084 * @param entryId the primary key of the current blogs entry 3085 * @param groupId the group ID 3086 * @param userId the user ID 3087 * @param status the status 3088 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3089 * @return the previous, current, and next blogs entry 3090 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 3091 */ 3092 public static BlogsEntry[] filterFindByG_U_S_PrevAndNext(long entryId, 3093 long groupId, long userId, int status, 3094 OrderByComparator<BlogsEntry> orderByComparator) 3095 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 3096 return getPersistence() 3097 .filterFindByG_U_S_PrevAndNext(entryId, groupId, userId, 3098 status, orderByComparator); 3099 } 3100 3101 /** 3102 * Returns all the blogs entries that the user has permission to view where groupId = ? and userId = ? and status = any ?. 3103 * 3104 * @param groupId the group ID 3105 * @param userId the user ID 3106 * @param statuses the statuses 3107 * @return the matching blogs entries that the user has permission to view 3108 */ 3109 public static List<BlogsEntry> filterFindByG_U_S(long groupId, long userId, 3110 int[] statuses) { 3111 return getPersistence().filterFindByG_U_S(groupId, userId, statuses); 3112 } 3113 3114 /** 3115 * Returns a range of all the blogs entries that the user has permission to view where groupId = ? and userId = ? and status = any ?. 3116 * 3117 * <p> 3118 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3119 * </p> 3120 * 3121 * @param groupId the group ID 3122 * @param userId the user ID 3123 * @param statuses the statuses 3124 * @param start the lower bound of the range of blogs entries 3125 * @param end the upper bound of the range of blogs entries (not inclusive) 3126 * @return the range of matching blogs entries that the user has permission to view 3127 */ 3128 public static List<BlogsEntry> filterFindByG_U_S(long groupId, long userId, 3129 int[] statuses, int start, int end) { 3130 return getPersistence() 3131 .filterFindByG_U_S(groupId, userId, statuses, start, end); 3132 } 3133 3134 /** 3135 * Returns an ordered range of all the blogs entries that the user has permission to view where groupId = ? and userId = ? and status = any ?. 3136 * 3137 * <p> 3138 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3139 * </p> 3140 * 3141 * @param groupId the group ID 3142 * @param userId the user ID 3143 * @param statuses the statuses 3144 * @param start the lower bound of the range of blogs entries 3145 * @param end the upper bound of the range of blogs entries (not inclusive) 3146 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3147 * @return the ordered range of matching blogs entries that the user has permission to view 3148 */ 3149 public static List<BlogsEntry> filterFindByG_U_S(long groupId, long userId, 3150 int[] statuses, int start, int end, 3151 OrderByComparator<BlogsEntry> orderByComparator) { 3152 return getPersistence() 3153 .filterFindByG_U_S(groupId, userId, statuses, start, end, 3154 orderByComparator); 3155 } 3156 3157 /** 3158 * Returns all the blogs entries where groupId = ? and userId = ? and status = any ?. 3159 * 3160 * <p> 3161 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3162 * </p> 3163 * 3164 * @param groupId the group ID 3165 * @param userId the user ID 3166 * @param statuses the statuses 3167 * @return the matching blogs entries 3168 */ 3169 public static List<BlogsEntry> findByG_U_S(long groupId, long userId, 3170 int[] statuses) { 3171 return getPersistence().findByG_U_S(groupId, userId, statuses); 3172 } 3173 3174 /** 3175 * Returns a range of all the blogs entries where groupId = ? and userId = ? and status = any ?. 3176 * 3177 * <p> 3178 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3179 * </p> 3180 * 3181 * @param groupId the group ID 3182 * @param userId the user ID 3183 * @param statuses the statuses 3184 * @param start the lower bound of the range of blogs entries 3185 * @param end the upper bound of the range of blogs entries (not inclusive) 3186 * @return the range of matching blogs entries 3187 */ 3188 public static List<BlogsEntry> findByG_U_S(long groupId, long userId, 3189 int[] statuses, int start, int end) { 3190 return getPersistence() 3191 .findByG_U_S(groupId, userId, statuses, start, end); 3192 } 3193 3194 /** 3195 * Returns an ordered range of all the blogs entries where groupId = ? and userId = ? and status = any ?. 3196 * 3197 * <p> 3198 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3199 * </p> 3200 * 3201 * @param groupId the group ID 3202 * @param userId the user ID 3203 * @param statuses the statuses 3204 * @param start the lower bound of the range of blogs entries 3205 * @param end the upper bound of the range of blogs entries (not inclusive) 3206 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3207 * @return the ordered range of matching blogs entries 3208 */ 3209 public static List<BlogsEntry> findByG_U_S(long groupId, long userId, 3210 int[] statuses, int start, int end, 3211 OrderByComparator<BlogsEntry> orderByComparator) { 3212 return getPersistence() 3213 .findByG_U_S(groupId, userId, statuses, start, end, 3214 orderByComparator); 3215 } 3216 3217 /** 3218 * Returns an ordered range of all the blogs entries where groupId = ? and userId = ? and status = ?, optionally using the finder cache. 3219 * 3220 * <p> 3221 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3222 * </p> 3223 * 3224 * @param groupId the group ID 3225 * @param userId the user ID 3226 * @param status the status 3227 * @param start the lower bound of the range of blogs entries 3228 * @param end the upper bound of the range of blogs entries (not inclusive) 3229 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3230 * @param retrieveFromCache whether to retrieve from the finder cache 3231 * @return the ordered range of matching blogs entries 3232 */ 3233 public static List<BlogsEntry> findByG_U_S(long groupId, long userId, 3234 int[] statuses, int start, int end, 3235 OrderByComparator<BlogsEntry> orderByComparator, 3236 boolean retrieveFromCache) { 3237 return getPersistence() 3238 .findByG_U_S(groupId, userId, statuses, start, end, 3239 orderByComparator, retrieveFromCache); 3240 } 3241 3242 /** 3243 * Removes all the blogs entries where groupId = ? and userId = ? and status = ? from the database. 3244 * 3245 * @param groupId the group ID 3246 * @param userId the user ID 3247 * @param status the status 3248 */ 3249 public static void removeByG_U_S(long groupId, long userId, int status) { 3250 getPersistence().removeByG_U_S(groupId, userId, status); 3251 } 3252 3253 /** 3254 * Returns the number of blogs entries where groupId = ? and userId = ? and status = ?. 3255 * 3256 * @param groupId the group ID 3257 * @param userId the user ID 3258 * @param status the status 3259 * @return the number of matching blogs entries 3260 */ 3261 public static int countByG_U_S(long groupId, long userId, int status) { 3262 return getPersistence().countByG_U_S(groupId, userId, status); 3263 } 3264 3265 /** 3266 * Returns the number of blogs entries where groupId = ? and userId = ? and status = any ?. 3267 * 3268 * @param groupId the group ID 3269 * @param userId the user ID 3270 * @param statuses the statuses 3271 * @return the number of matching blogs entries 3272 */ 3273 public static int countByG_U_S(long groupId, long userId, int[] statuses) { 3274 return getPersistence().countByG_U_S(groupId, userId, statuses); 3275 } 3276 3277 /** 3278 * Returns the number of blogs entries that the user has permission to view where groupId = ? and userId = ? and status = ?. 3279 * 3280 * @param groupId the group ID 3281 * @param userId the user ID 3282 * @param status the status 3283 * @return the number of matching blogs entries that the user has permission to view 3284 */ 3285 public static int filterCountByG_U_S(long groupId, long userId, int status) { 3286 return getPersistence().filterCountByG_U_S(groupId, userId, status); 3287 } 3288 3289 /** 3290 * Returns the number of blogs entries that the user has permission to view where groupId = ? and userId = ? and status = any ?. 3291 * 3292 * @param groupId the group ID 3293 * @param userId the user ID 3294 * @param statuses the statuses 3295 * @return the number of matching blogs entries that the user has permission to view 3296 */ 3297 public static int filterCountByG_U_S(long groupId, long userId, 3298 int[] statuses) { 3299 return getPersistence().filterCountByG_U_S(groupId, userId, statuses); 3300 } 3301 3302 /** 3303 * Returns all the blogs entries where groupId = ? and userId = ? and status ≠ ?. 3304 * 3305 * @param groupId the group ID 3306 * @param userId the user ID 3307 * @param status the status 3308 * @return the matching blogs entries 3309 */ 3310 public static List<BlogsEntry> findByG_U_NotS(long groupId, long userId, 3311 int status) { 3312 return getPersistence().findByG_U_NotS(groupId, userId, status); 3313 } 3314 3315 /** 3316 * Returns a range of all the blogs entries where groupId = ? and userId = ? and status ≠ ?. 3317 * 3318 * <p> 3319 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3320 * </p> 3321 * 3322 * @param groupId the group ID 3323 * @param userId the user ID 3324 * @param status the status 3325 * @param start the lower bound of the range of blogs entries 3326 * @param end the upper bound of the range of blogs entries (not inclusive) 3327 * @return the range of matching blogs entries 3328 */ 3329 public static List<BlogsEntry> findByG_U_NotS(long groupId, long userId, 3330 int status, int start, int end) { 3331 return getPersistence() 3332 .findByG_U_NotS(groupId, userId, status, start, end); 3333 } 3334 3335 /** 3336 * Returns an ordered range of all the blogs entries where groupId = ? and userId = ? and status ≠ ?. 3337 * 3338 * <p> 3339 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3340 * </p> 3341 * 3342 * @param groupId the group ID 3343 * @param userId the user ID 3344 * @param status the status 3345 * @param start the lower bound of the range of blogs entries 3346 * @param end the upper bound of the range of blogs entries (not inclusive) 3347 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3348 * @return the ordered range of matching blogs entries 3349 */ 3350 public static List<BlogsEntry> findByG_U_NotS(long groupId, long userId, 3351 int status, int start, int end, 3352 OrderByComparator<BlogsEntry> orderByComparator) { 3353 return getPersistence() 3354 .findByG_U_NotS(groupId, userId, status, start, end, 3355 orderByComparator); 3356 } 3357 3358 /** 3359 * Returns an ordered range of all the blogs entries where groupId = ? and userId = ? and status ≠ ?. 3360 * 3361 * <p> 3362 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3363 * </p> 3364 * 3365 * @param groupId the group ID 3366 * @param userId the user ID 3367 * @param status the status 3368 * @param start the lower bound of the range of blogs entries 3369 * @param end the upper bound of the range of blogs entries (not inclusive) 3370 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3371 * @param retrieveFromCache whether to retrieve from the finder cache 3372 * @return the ordered range of matching blogs entries 3373 */ 3374 public static List<BlogsEntry> findByG_U_NotS(long groupId, long userId, 3375 int status, int start, int end, 3376 OrderByComparator<BlogsEntry> orderByComparator, 3377 boolean retrieveFromCache) { 3378 return getPersistence() 3379 .findByG_U_NotS(groupId, userId, status, start, end, 3380 orderByComparator, retrieveFromCache); 3381 } 3382 3383 /** 3384 * Returns the first blogs entry in the ordered set where groupId = ? and userId = ? and status ≠ ?. 3385 * 3386 * @param groupId the group ID 3387 * @param userId the user ID 3388 * @param status the status 3389 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3390 * @return the first matching blogs entry 3391 * @throws NoSuchEntryException if a matching blogs entry could not be found 3392 */ 3393 public static BlogsEntry findByG_U_NotS_First(long groupId, long userId, 3394 int status, OrderByComparator<BlogsEntry> orderByComparator) 3395 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 3396 return getPersistence() 3397 .findByG_U_NotS_First(groupId, userId, status, 3398 orderByComparator); 3399 } 3400 3401 /** 3402 * Returns the first blogs entry in the ordered set where groupId = ? and userId = ? and status ≠ ?. 3403 * 3404 * @param groupId the group ID 3405 * @param userId the user ID 3406 * @param status the status 3407 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3408 * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 3409 */ 3410 public static BlogsEntry fetchByG_U_NotS_First(long groupId, long userId, 3411 int status, OrderByComparator<BlogsEntry> orderByComparator) { 3412 return getPersistence() 3413 .fetchByG_U_NotS_First(groupId, userId, status, 3414 orderByComparator); 3415 } 3416 3417 /** 3418 * Returns the last blogs entry in the ordered set where groupId = ? and userId = ? and status ≠ ?. 3419 * 3420 * @param groupId the group ID 3421 * @param userId the user ID 3422 * @param status the status 3423 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3424 * @return the last matching blogs entry 3425 * @throws NoSuchEntryException if a matching blogs entry could not be found 3426 */ 3427 public static BlogsEntry findByG_U_NotS_Last(long groupId, long userId, 3428 int status, OrderByComparator<BlogsEntry> orderByComparator) 3429 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 3430 return getPersistence() 3431 .findByG_U_NotS_Last(groupId, userId, status, 3432 orderByComparator); 3433 } 3434 3435 /** 3436 * Returns the last blogs entry in the ordered set where groupId = ? and userId = ? and status ≠ ?. 3437 * 3438 * @param groupId the group ID 3439 * @param userId the user ID 3440 * @param status the status 3441 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3442 * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 3443 */ 3444 public static BlogsEntry fetchByG_U_NotS_Last(long groupId, long userId, 3445 int status, OrderByComparator<BlogsEntry> orderByComparator) { 3446 return getPersistence() 3447 .fetchByG_U_NotS_Last(groupId, userId, status, 3448 orderByComparator); 3449 } 3450 3451 /** 3452 * Returns the blogs entries before and after the current blogs entry in the ordered set where groupId = ? and userId = ? and status ≠ ?. 3453 * 3454 * @param entryId the primary key of the current blogs entry 3455 * @param groupId the group ID 3456 * @param userId the user ID 3457 * @param status the status 3458 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3459 * @return the previous, current, and next blogs entry 3460 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 3461 */ 3462 public static BlogsEntry[] findByG_U_NotS_PrevAndNext(long entryId, 3463 long groupId, long userId, int status, 3464 OrderByComparator<BlogsEntry> orderByComparator) 3465 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 3466 return getPersistence() 3467 .findByG_U_NotS_PrevAndNext(entryId, groupId, userId, 3468 status, orderByComparator); 3469 } 3470 3471 /** 3472 * Returns all the blogs entries that the user has permission to view where groupId = ? and userId = ? and status ≠ ?. 3473 * 3474 * @param groupId the group ID 3475 * @param userId the user ID 3476 * @param status the status 3477 * @return the matching blogs entries that the user has permission to view 3478 */ 3479 public static List<BlogsEntry> filterFindByG_U_NotS(long groupId, 3480 long userId, int status) { 3481 return getPersistence().filterFindByG_U_NotS(groupId, userId, status); 3482 } 3483 3484 /** 3485 * Returns a range of all the blogs entries that the user has permission to view where groupId = ? and userId = ? and status ≠ ?. 3486 * 3487 * <p> 3488 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3489 * </p> 3490 * 3491 * @param groupId the group ID 3492 * @param userId the user ID 3493 * @param status the status 3494 * @param start the lower bound of the range of blogs entries 3495 * @param end the upper bound of the range of blogs entries (not inclusive) 3496 * @return the range of matching blogs entries that the user has permission to view 3497 */ 3498 public static List<BlogsEntry> filterFindByG_U_NotS(long groupId, 3499 long userId, int status, int start, int end) { 3500 return getPersistence() 3501 .filterFindByG_U_NotS(groupId, userId, status, start, end); 3502 } 3503 3504 /** 3505 * Returns an ordered range of all the blogs entries that the user has permissions to view where groupId = ? and userId = ? and status ≠ ?. 3506 * 3507 * <p> 3508 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3509 * </p> 3510 * 3511 * @param groupId the group ID 3512 * @param userId the user ID 3513 * @param status the status 3514 * @param start the lower bound of the range of blogs entries 3515 * @param end the upper bound of the range of blogs entries (not inclusive) 3516 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3517 * @return the ordered range of matching blogs entries that the user has permission to view 3518 */ 3519 public static List<BlogsEntry> filterFindByG_U_NotS(long groupId, 3520 long userId, int status, int start, int end, 3521 OrderByComparator<BlogsEntry> orderByComparator) { 3522 return getPersistence() 3523 .filterFindByG_U_NotS(groupId, userId, status, start, end, 3524 orderByComparator); 3525 } 3526 3527 /** 3528 * 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 ≠ ?. 3529 * 3530 * @param entryId the primary key of the current blogs entry 3531 * @param groupId the group ID 3532 * @param userId the user ID 3533 * @param status the status 3534 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3535 * @return the previous, current, and next blogs entry 3536 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 3537 */ 3538 public static BlogsEntry[] filterFindByG_U_NotS_PrevAndNext(long entryId, 3539 long groupId, long userId, int status, 3540 OrderByComparator<BlogsEntry> orderByComparator) 3541 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 3542 return getPersistence() 3543 .filterFindByG_U_NotS_PrevAndNext(entryId, groupId, userId, 3544 status, orderByComparator); 3545 } 3546 3547 /** 3548 * Removes all the blogs entries where groupId = ? and userId = ? and status ≠ ? from the database. 3549 * 3550 * @param groupId the group ID 3551 * @param userId the user ID 3552 * @param status the status 3553 */ 3554 public static void removeByG_U_NotS(long groupId, long userId, int status) { 3555 getPersistence().removeByG_U_NotS(groupId, userId, status); 3556 } 3557 3558 /** 3559 * Returns the number of blogs entries where groupId = ? and userId = ? and status ≠ ?. 3560 * 3561 * @param groupId the group ID 3562 * @param userId the user ID 3563 * @param status the status 3564 * @return the number of matching blogs entries 3565 */ 3566 public static int countByG_U_NotS(long groupId, long userId, int status) { 3567 return getPersistence().countByG_U_NotS(groupId, userId, status); 3568 } 3569 3570 /** 3571 * Returns the number of blogs entries that the user has permission to view where groupId = ? and userId = ? and status ≠ ?. 3572 * 3573 * @param groupId the group ID 3574 * @param userId the user ID 3575 * @param status the status 3576 * @return the number of matching blogs entries that the user has permission to view 3577 */ 3578 public static int filterCountByG_U_NotS(long groupId, long userId, 3579 int status) { 3580 return getPersistence().filterCountByG_U_NotS(groupId, userId, status); 3581 } 3582 3583 /** 3584 * Returns all the blogs entries where groupId = ? and displayDate < ? and status = ?. 3585 * 3586 * @param groupId the group ID 3587 * @param displayDate the display date 3588 * @param status the status 3589 * @return the matching blogs entries 3590 */ 3591 public static List<BlogsEntry> findByG_LtD_S(long groupId, 3592 Date displayDate, int status) { 3593 return getPersistence().findByG_LtD_S(groupId, displayDate, status); 3594 } 3595 3596 /** 3597 * Returns a range of all the blogs entries where groupId = ? and displayDate < ? and status = ?. 3598 * 3599 * <p> 3600 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3601 * </p> 3602 * 3603 * @param groupId the group ID 3604 * @param displayDate the display date 3605 * @param status the status 3606 * @param start the lower bound of the range of blogs entries 3607 * @param end the upper bound of the range of blogs entries (not inclusive) 3608 * @return the range of matching blogs entries 3609 */ 3610 public static List<BlogsEntry> findByG_LtD_S(long groupId, 3611 Date displayDate, int status, int start, int end) { 3612 return getPersistence() 3613 .findByG_LtD_S(groupId, displayDate, status, start, end); 3614 } 3615 3616 /** 3617 * Returns an ordered range of all the blogs entries where groupId = ? and displayDate < ? and status = ?. 3618 * 3619 * <p> 3620 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3621 * </p> 3622 * 3623 * @param groupId the group ID 3624 * @param displayDate the display date 3625 * @param status the status 3626 * @param start the lower bound of the range of blogs entries 3627 * @param end the upper bound of the range of blogs entries (not inclusive) 3628 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3629 * @return the ordered range of matching blogs entries 3630 */ 3631 public static List<BlogsEntry> findByG_LtD_S(long groupId, 3632 Date displayDate, int status, int start, int end, 3633 OrderByComparator<BlogsEntry> orderByComparator) { 3634 return getPersistence() 3635 .findByG_LtD_S(groupId, displayDate, status, start, end, 3636 orderByComparator); 3637 } 3638 3639 /** 3640 * Returns an ordered range of all the blogs entries where groupId = ? and displayDate < ? and status = ?. 3641 * 3642 * <p> 3643 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3644 * </p> 3645 * 3646 * @param groupId the group ID 3647 * @param displayDate the display date 3648 * @param status the status 3649 * @param start the lower bound of the range of blogs entries 3650 * @param end the upper bound of the range of blogs entries (not inclusive) 3651 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3652 * @param retrieveFromCache whether to retrieve from the finder cache 3653 * @return the ordered range of matching blogs entries 3654 */ 3655 public static List<BlogsEntry> findByG_LtD_S(long groupId, 3656 Date displayDate, int status, int start, int end, 3657 OrderByComparator<BlogsEntry> orderByComparator, 3658 boolean retrieveFromCache) { 3659 return getPersistence() 3660 .findByG_LtD_S(groupId, displayDate, status, start, end, 3661 orderByComparator, retrieveFromCache); 3662 } 3663 3664 /** 3665 * Returns the first blogs entry in the ordered set where groupId = ? and displayDate < ? and status = ?. 3666 * 3667 * @param groupId the group ID 3668 * @param displayDate the display date 3669 * @param status the status 3670 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3671 * @return the first matching blogs entry 3672 * @throws NoSuchEntryException if a matching blogs entry could not be found 3673 */ 3674 public static BlogsEntry findByG_LtD_S_First(long groupId, 3675 Date displayDate, int status, 3676 OrderByComparator<BlogsEntry> orderByComparator) 3677 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 3678 return getPersistence() 3679 .findByG_LtD_S_First(groupId, displayDate, status, 3680 orderByComparator); 3681 } 3682 3683 /** 3684 * Returns the first blogs entry in the ordered set where groupId = ? and displayDate < ? and status = ?. 3685 * 3686 * @param groupId the group ID 3687 * @param displayDate the display date 3688 * @param status the status 3689 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3690 * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 3691 */ 3692 public static BlogsEntry fetchByG_LtD_S_First(long groupId, 3693 Date displayDate, int status, 3694 OrderByComparator<BlogsEntry> orderByComparator) { 3695 return getPersistence() 3696 .fetchByG_LtD_S_First(groupId, displayDate, status, 3697 orderByComparator); 3698 } 3699 3700 /** 3701 * Returns the last blogs entry in the ordered set where groupId = ? and displayDate < ? and status = ?. 3702 * 3703 * @param groupId the group ID 3704 * @param displayDate the display date 3705 * @param status the status 3706 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3707 * @return the last matching blogs entry 3708 * @throws NoSuchEntryException if a matching blogs entry could not be found 3709 */ 3710 public static BlogsEntry findByG_LtD_S_Last(long groupId, Date displayDate, 3711 int status, OrderByComparator<BlogsEntry> orderByComparator) 3712 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 3713 return getPersistence() 3714 .findByG_LtD_S_Last(groupId, displayDate, status, 3715 orderByComparator); 3716 } 3717 3718 /** 3719 * Returns the last blogs entry in the ordered set where groupId = ? and displayDate < ? and status = ?. 3720 * 3721 * @param groupId the group ID 3722 * @param displayDate the display date 3723 * @param status the status 3724 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3725 * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 3726 */ 3727 public static BlogsEntry fetchByG_LtD_S_Last(long groupId, 3728 Date displayDate, int status, 3729 OrderByComparator<BlogsEntry> orderByComparator) { 3730 return getPersistence() 3731 .fetchByG_LtD_S_Last(groupId, displayDate, status, 3732 orderByComparator); 3733 } 3734 3735 /** 3736 * Returns the blogs entries before and after the current blogs entry in the ordered set where groupId = ? and displayDate < ? and status = ?. 3737 * 3738 * @param entryId the primary key of the current blogs entry 3739 * @param groupId the group ID 3740 * @param displayDate the display date 3741 * @param status the status 3742 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3743 * @return the previous, current, and next blogs entry 3744 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 3745 */ 3746 public static BlogsEntry[] findByG_LtD_S_PrevAndNext(long entryId, 3747 long groupId, Date displayDate, int status, 3748 OrderByComparator<BlogsEntry> orderByComparator) 3749 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 3750 return getPersistence() 3751 .findByG_LtD_S_PrevAndNext(entryId, groupId, displayDate, 3752 status, orderByComparator); 3753 } 3754 3755 /** 3756 * Returns all the blogs entries that the user has permission to view where groupId = ? and displayDate < ? and status = ?. 3757 * 3758 * @param groupId the group ID 3759 * @param displayDate the display date 3760 * @param status the status 3761 * @return the matching blogs entries that the user has permission to view 3762 */ 3763 public static List<BlogsEntry> filterFindByG_LtD_S(long groupId, 3764 Date displayDate, int status) { 3765 return getPersistence().filterFindByG_LtD_S(groupId, displayDate, status); 3766 } 3767 3768 /** 3769 * Returns a range of all the blogs entries that the user has permission to view where groupId = ? and displayDate < ? and status = ?. 3770 * 3771 * <p> 3772 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3773 * </p> 3774 * 3775 * @param groupId the group ID 3776 * @param displayDate the display date 3777 * @param status the status 3778 * @param start the lower bound of the range of blogs entries 3779 * @param end the upper bound of the range of blogs entries (not inclusive) 3780 * @return the range of matching blogs entries that the user has permission to view 3781 */ 3782 public static List<BlogsEntry> filterFindByG_LtD_S(long groupId, 3783 Date displayDate, int status, int start, int end) { 3784 return getPersistence() 3785 .filterFindByG_LtD_S(groupId, displayDate, status, start, end); 3786 } 3787 3788 /** 3789 * Returns an ordered range of all the blogs entries that the user has permissions to view where groupId = ? and displayDate < ? and status = ?. 3790 * 3791 * <p> 3792 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3793 * </p> 3794 * 3795 * @param groupId the group ID 3796 * @param displayDate the display date 3797 * @param status the status 3798 * @param start the lower bound of the range of blogs entries 3799 * @param end the upper bound of the range of blogs entries (not inclusive) 3800 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3801 * @return the ordered range of matching blogs entries that the user has permission to view 3802 */ 3803 public static List<BlogsEntry> filterFindByG_LtD_S(long groupId, 3804 Date displayDate, int status, int start, int end, 3805 OrderByComparator<BlogsEntry> orderByComparator) { 3806 return getPersistence() 3807 .filterFindByG_LtD_S(groupId, displayDate, status, start, 3808 end, orderByComparator); 3809 } 3810 3811 /** 3812 * 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 = ?. 3813 * 3814 * @param entryId the primary key of the current blogs entry 3815 * @param groupId the group ID 3816 * @param displayDate the display date 3817 * @param status the status 3818 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3819 * @return the previous, current, and next blogs entry 3820 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 3821 */ 3822 public static BlogsEntry[] filterFindByG_LtD_S_PrevAndNext(long entryId, 3823 long groupId, Date displayDate, int status, 3824 OrderByComparator<BlogsEntry> orderByComparator) 3825 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 3826 return getPersistence() 3827 .filterFindByG_LtD_S_PrevAndNext(entryId, groupId, 3828 displayDate, status, orderByComparator); 3829 } 3830 3831 /** 3832 * Removes all the blogs entries where groupId = ? and displayDate < ? and status = ? from the database. 3833 * 3834 * @param groupId the group ID 3835 * @param displayDate the display date 3836 * @param status the status 3837 */ 3838 public static void removeByG_LtD_S(long groupId, Date displayDate, 3839 int status) { 3840 getPersistence().removeByG_LtD_S(groupId, displayDate, status); 3841 } 3842 3843 /** 3844 * Returns the number of blogs entries where groupId = ? and displayDate < ? and status = ?. 3845 * 3846 * @param groupId the group ID 3847 * @param displayDate the display date 3848 * @param status the status 3849 * @return the number of matching blogs entries 3850 */ 3851 public static int countByG_LtD_S(long groupId, Date displayDate, int status) { 3852 return getPersistence().countByG_LtD_S(groupId, displayDate, status); 3853 } 3854 3855 /** 3856 * Returns the number of blogs entries that the user has permission to view where groupId = ? and displayDate < ? and status = ?. 3857 * 3858 * @param groupId the group ID 3859 * @param displayDate the display date 3860 * @param status the status 3861 * @return the number of matching blogs entries that the user has permission to view 3862 */ 3863 public static int filterCountByG_LtD_S(long groupId, Date displayDate, 3864 int status) { 3865 return getPersistence() 3866 .filterCountByG_LtD_S(groupId, displayDate, status); 3867 } 3868 3869 /** 3870 * Returns all the blogs entries where groupId = ? and displayDate < ? and status ≠ ?. 3871 * 3872 * @param groupId the group ID 3873 * @param displayDate the display date 3874 * @param status the status 3875 * @return the matching blogs entries 3876 */ 3877 public static List<BlogsEntry> findByG_LtD_NotS(long groupId, 3878 Date displayDate, int status) { 3879 return getPersistence().findByG_LtD_NotS(groupId, displayDate, status); 3880 } 3881 3882 /** 3883 * Returns a range of all the blogs entries where groupId = ? and displayDate < ? and status ≠ ?. 3884 * 3885 * <p> 3886 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3887 * </p> 3888 * 3889 * @param groupId the group ID 3890 * @param displayDate the display date 3891 * @param status the status 3892 * @param start the lower bound of the range of blogs entries 3893 * @param end the upper bound of the range of blogs entries (not inclusive) 3894 * @return the range of matching blogs entries 3895 */ 3896 public static List<BlogsEntry> findByG_LtD_NotS(long groupId, 3897 Date displayDate, int status, int start, int end) { 3898 return getPersistence() 3899 .findByG_LtD_NotS(groupId, displayDate, status, start, end); 3900 } 3901 3902 /** 3903 * Returns an ordered range of all the blogs entries where groupId = ? and displayDate < ? and status ≠ ?. 3904 * 3905 * <p> 3906 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3907 * </p> 3908 * 3909 * @param groupId the group ID 3910 * @param displayDate the display date 3911 * @param status the status 3912 * @param start the lower bound of the range of blogs entries 3913 * @param end the upper bound of the range of blogs entries (not inclusive) 3914 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3915 * @return the ordered range of matching blogs entries 3916 */ 3917 public static List<BlogsEntry> findByG_LtD_NotS(long groupId, 3918 Date displayDate, int status, int start, int end, 3919 OrderByComparator<BlogsEntry> orderByComparator) { 3920 return getPersistence() 3921 .findByG_LtD_NotS(groupId, displayDate, status, start, end, 3922 orderByComparator); 3923 } 3924 3925 /** 3926 * Returns an ordered range of all the blogs entries where groupId = ? and displayDate < ? and status ≠ ?. 3927 * 3928 * <p> 3929 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 3930 * </p> 3931 * 3932 * @param groupId the group ID 3933 * @param displayDate the display date 3934 * @param status the status 3935 * @param start the lower bound of the range of blogs entries 3936 * @param end the upper bound of the range of blogs entries (not inclusive) 3937 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3938 * @param retrieveFromCache whether to retrieve from the finder cache 3939 * @return the ordered range of matching blogs entries 3940 */ 3941 public static List<BlogsEntry> findByG_LtD_NotS(long groupId, 3942 Date displayDate, int status, int start, int end, 3943 OrderByComparator<BlogsEntry> orderByComparator, 3944 boolean retrieveFromCache) { 3945 return getPersistence() 3946 .findByG_LtD_NotS(groupId, displayDate, status, start, end, 3947 orderByComparator, retrieveFromCache); 3948 } 3949 3950 /** 3951 * Returns the first blogs entry in the ordered set where groupId = ? and displayDate < ? and status ≠ ?. 3952 * 3953 * @param groupId the group ID 3954 * @param displayDate the display date 3955 * @param status the status 3956 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3957 * @return the first matching blogs entry 3958 * @throws NoSuchEntryException if a matching blogs entry could not be found 3959 */ 3960 public static BlogsEntry findByG_LtD_NotS_First(long groupId, 3961 Date displayDate, int status, 3962 OrderByComparator<BlogsEntry> orderByComparator) 3963 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 3964 return getPersistence() 3965 .findByG_LtD_NotS_First(groupId, displayDate, status, 3966 orderByComparator); 3967 } 3968 3969 /** 3970 * Returns the first blogs entry in the ordered set where groupId = ? and displayDate < ? and status ≠ ?. 3971 * 3972 * @param groupId the group ID 3973 * @param displayDate the display date 3974 * @param status the status 3975 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3976 * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 3977 */ 3978 public static BlogsEntry fetchByG_LtD_NotS_First(long groupId, 3979 Date displayDate, int status, 3980 OrderByComparator<BlogsEntry> orderByComparator) { 3981 return getPersistence() 3982 .fetchByG_LtD_NotS_First(groupId, displayDate, status, 3983 orderByComparator); 3984 } 3985 3986 /** 3987 * Returns the last blogs entry in the ordered set where groupId = ? and displayDate < ? and status ≠ ?. 3988 * 3989 * @param groupId the group ID 3990 * @param displayDate the display date 3991 * @param status the status 3992 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3993 * @return the last matching blogs entry 3994 * @throws NoSuchEntryException if a matching blogs entry could not be found 3995 */ 3996 public static BlogsEntry findByG_LtD_NotS_Last(long groupId, 3997 Date displayDate, int status, 3998 OrderByComparator<BlogsEntry> orderByComparator) 3999 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 4000 return getPersistence() 4001 .findByG_LtD_NotS_Last(groupId, displayDate, status, 4002 orderByComparator); 4003 } 4004 4005 /** 4006 * Returns the last blogs entry in the ordered set where groupId = ? and displayDate < ? and status ≠ ?. 4007 * 4008 * @param groupId the group ID 4009 * @param displayDate the display date 4010 * @param status the status 4011 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4012 * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 4013 */ 4014 public static BlogsEntry fetchByG_LtD_NotS_Last(long groupId, 4015 Date displayDate, int status, 4016 OrderByComparator<BlogsEntry> orderByComparator) { 4017 return getPersistence() 4018 .fetchByG_LtD_NotS_Last(groupId, displayDate, status, 4019 orderByComparator); 4020 } 4021 4022 /** 4023 * Returns the blogs entries before and after the current blogs entry in the ordered set where groupId = ? and displayDate < ? and status ≠ ?. 4024 * 4025 * @param entryId the primary key of the current blogs entry 4026 * @param groupId the group ID 4027 * @param displayDate the display date 4028 * @param status the status 4029 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4030 * @return the previous, current, and next blogs entry 4031 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 4032 */ 4033 public static BlogsEntry[] findByG_LtD_NotS_PrevAndNext(long entryId, 4034 long groupId, Date displayDate, int status, 4035 OrderByComparator<BlogsEntry> orderByComparator) 4036 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 4037 return getPersistence() 4038 .findByG_LtD_NotS_PrevAndNext(entryId, groupId, displayDate, 4039 status, orderByComparator); 4040 } 4041 4042 /** 4043 * Returns all the blogs entries that the user has permission to view where groupId = ? and displayDate < ? and status ≠ ?. 4044 * 4045 * @param groupId the group ID 4046 * @param displayDate the display date 4047 * @param status the status 4048 * @return the matching blogs entries that the user has permission to view 4049 */ 4050 public static List<BlogsEntry> filterFindByG_LtD_NotS(long groupId, 4051 Date displayDate, int status) { 4052 return getPersistence() 4053 .filterFindByG_LtD_NotS(groupId, displayDate, status); 4054 } 4055 4056 /** 4057 * Returns a range of all the blogs entries that the user has permission to view where groupId = ? and displayDate < ? and status ≠ ?. 4058 * 4059 * <p> 4060 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4061 * </p> 4062 * 4063 * @param groupId the group ID 4064 * @param displayDate the display date 4065 * @param status the status 4066 * @param start the lower bound of the range of blogs entries 4067 * @param end the upper bound of the range of blogs entries (not inclusive) 4068 * @return the range of matching blogs entries that the user has permission to view 4069 */ 4070 public static List<BlogsEntry> filterFindByG_LtD_NotS(long groupId, 4071 Date displayDate, int status, int start, int end) { 4072 return getPersistence() 4073 .filterFindByG_LtD_NotS(groupId, displayDate, status, start, 4074 end); 4075 } 4076 4077 /** 4078 * Returns an ordered range of all the blogs entries that the user has permissions to view where groupId = ? and displayDate < ? and status ≠ ?. 4079 * 4080 * <p> 4081 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4082 * </p> 4083 * 4084 * @param groupId the group ID 4085 * @param displayDate the display date 4086 * @param status the status 4087 * @param start the lower bound of the range of blogs entries 4088 * @param end the upper bound of the range of blogs entries (not inclusive) 4089 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4090 * @return the ordered range of matching blogs entries that the user has permission to view 4091 */ 4092 public static List<BlogsEntry> filterFindByG_LtD_NotS(long groupId, 4093 Date displayDate, int status, int start, int end, 4094 OrderByComparator<BlogsEntry> orderByComparator) { 4095 return getPersistence() 4096 .filterFindByG_LtD_NotS(groupId, displayDate, status, start, 4097 end, orderByComparator); 4098 } 4099 4100 /** 4101 * 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 ≠ ?. 4102 * 4103 * @param entryId the primary key of the current blogs entry 4104 * @param groupId the group ID 4105 * @param displayDate the display date 4106 * @param status the status 4107 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4108 * @return the previous, current, and next blogs entry 4109 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 4110 */ 4111 public static BlogsEntry[] filterFindByG_LtD_NotS_PrevAndNext( 4112 long entryId, long groupId, Date displayDate, int status, 4113 OrderByComparator<BlogsEntry> orderByComparator) 4114 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 4115 return getPersistence() 4116 .filterFindByG_LtD_NotS_PrevAndNext(entryId, groupId, 4117 displayDate, status, orderByComparator); 4118 } 4119 4120 /** 4121 * Removes all the blogs entries where groupId = ? and displayDate < ? and status ≠ ? from the database. 4122 * 4123 * @param groupId the group ID 4124 * @param displayDate the display date 4125 * @param status the status 4126 */ 4127 public static void removeByG_LtD_NotS(long groupId, Date displayDate, 4128 int status) { 4129 getPersistence().removeByG_LtD_NotS(groupId, displayDate, status); 4130 } 4131 4132 /** 4133 * Returns the number of blogs entries where groupId = ? and displayDate < ? and status ≠ ?. 4134 * 4135 * @param groupId the group ID 4136 * @param displayDate the display date 4137 * @param status the status 4138 * @return the number of matching blogs entries 4139 */ 4140 public static int countByG_LtD_NotS(long groupId, Date displayDate, 4141 int status) { 4142 return getPersistence().countByG_LtD_NotS(groupId, displayDate, status); 4143 } 4144 4145 /** 4146 * Returns the number of blogs entries that the user has permission to view where groupId = ? and displayDate < ? and status ≠ ?. 4147 * 4148 * @param groupId the group ID 4149 * @param displayDate the display date 4150 * @param status the status 4151 * @return the number of matching blogs entries that the user has permission to view 4152 */ 4153 public static int filterCountByG_LtD_NotS(long groupId, Date displayDate, 4154 int status) { 4155 return getPersistence() 4156 .filterCountByG_LtD_NotS(groupId, displayDate, status); 4157 } 4158 4159 /** 4160 * Returns all the blogs entries where companyId = ? and userId = ? and status = ?. 4161 * 4162 * @param companyId the company ID 4163 * @param userId the user ID 4164 * @param status the status 4165 * @return the matching blogs entries 4166 */ 4167 public static List<BlogsEntry> findByC_U_S(long companyId, long userId, 4168 int status) { 4169 return getPersistence().findByC_U_S(companyId, userId, status); 4170 } 4171 4172 /** 4173 * Returns a range of all the blogs entries where companyId = ? and userId = ? and status = ?. 4174 * 4175 * <p> 4176 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4177 * </p> 4178 * 4179 * @param companyId the company ID 4180 * @param userId the user ID 4181 * @param status the status 4182 * @param start the lower bound of the range of blogs entries 4183 * @param end the upper bound of the range of blogs entries (not inclusive) 4184 * @return the range of matching blogs entries 4185 */ 4186 public static List<BlogsEntry> findByC_U_S(long companyId, long userId, 4187 int status, int start, int end) { 4188 return getPersistence() 4189 .findByC_U_S(companyId, userId, status, start, end); 4190 } 4191 4192 /** 4193 * Returns an ordered range of all the blogs entries where companyId = ? and userId = ? and status = ?. 4194 * 4195 * <p> 4196 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4197 * </p> 4198 * 4199 * @param companyId the company ID 4200 * @param userId the user ID 4201 * @param status the status 4202 * @param start the lower bound of the range of blogs entries 4203 * @param end the upper bound of the range of blogs entries (not inclusive) 4204 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4205 * @return the ordered range of matching blogs entries 4206 */ 4207 public static List<BlogsEntry> findByC_U_S(long companyId, long userId, 4208 int status, int start, int end, 4209 OrderByComparator<BlogsEntry> orderByComparator) { 4210 return getPersistence() 4211 .findByC_U_S(companyId, userId, status, start, end, 4212 orderByComparator); 4213 } 4214 4215 /** 4216 * Returns an ordered range of all the blogs entries where companyId = ? and userId = ? and status = ?. 4217 * 4218 * <p> 4219 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4220 * </p> 4221 * 4222 * @param companyId the company ID 4223 * @param userId the user ID 4224 * @param status the status 4225 * @param start the lower bound of the range of blogs entries 4226 * @param end the upper bound of the range of blogs entries (not inclusive) 4227 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4228 * @param retrieveFromCache whether to retrieve from the finder cache 4229 * @return the ordered range of matching blogs entries 4230 */ 4231 public static List<BlogsEntry> findByC_U_S(long companyId, long userId, 4232 int status, int start, int end, 4233 OrderByComparator<BlogsEntry> orderByComparator, 4234 boolean retrieveFromCache) { 4235 return getPersistence() 4236 .findByC_U_S(companyId, userId, status, start, end, 4237 orderByComparator, retrieveFromCache); 4238 } 4239 4240 /** 4241 * Returns the first blogs entry in the ordered set where companyId = ? and userId = ? and status = ?. 4242 * 4243 * @param companyId the company ID 4244 * @param userId the user ID 4245 * @param status the status 4246 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4247 * @return the first matching blogs entry 4248 * @throws NoSuchEntryException if a matching blogs entry could not be found 4249 */ 4250 public static BlogsEntry findByC_U_S_First(long companyId, long userId, 4251 int status, OrderByComparator<BlogsEntry> orderByComparator) 4252 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 4253 return getPersistence() 4254 .findByC_U_S_First(companyId, userId, status, 4255 orderByComparator); 4256 } 4257 4258 /** 4259 * Returns the first blogs entry in the ordered set where companyId = ? and userId = ? and status = ?. 4260 * 4261 * @param companyId the company ID 4262 * @param userId the user ID 4263 * @param status the status 4264 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4265 * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 4266 */ 4267 public static BlogsEntry fetchByC_U_S_First(long companyId, long userId, 4268 int status, OrderByComparator<BlogsEntry> orderByComparator) { 4269 return getPersistence() 4270 .fetchByC_U_S_First(companyId, userId, status, 4271 orderByComparator); 4272 } 4273 4274 /** 4275 * Returns the last blogs entry in the ordered set where companyId = ? and userId = ? and status = ?. 4276 * 4277 * @param companyId the company ID 4278 * @param userId the user ID 4279 * @param status the status 4280 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4281 * @return the last matching blogs entry 4282 * @throws NoSuchEntryException if a matching blogs entry could not be found 4283 */ 4284 public static BlogsEntry findByC_U_S_Last(long companyId, long userId, 4285 int status, OrderByComparator<BlogsEntry> orderByComparator) 4286 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 4287 return getPersistence() 4288 .findByC_U_S_Last(companyId, userId, status, 4289 orderByComparator); 4290 } 4291 4292 /** 4293 * Returns the last blogs entry in the ordered set where companyId = ? and userId = ? and status = ?. 4294 * 4295 * @param companyId the company ID 4296 * @param userId the user ID 4297 * @param status the status 4298 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4299 * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 4300 */ 4301 public static BlogsEntry fetchByC_U_S_Last(long companyId, long userId, 4302 int status, OrderByComparator<BlogsEntry> orderByComparator) { 4303 return getPersistence() 4304 .fetchByC_U_S_Last(companyId, userId, status, 4305 orderByComparator); 4306 } 4307 4308 /** 4309 * Returns the blogs entries before and after the current blogs entry in the ordered set where companyId = ? and userId = ? and status = ?. 4310 * 4311 * @param entryId the primary key of the current blogs entry 4312 * @param companyId the company ID 4313 * @param userId the user ID 4314 * @param status the status 4315 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4316 * @return the previous, current, and next blogs entry 4317 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 4318 */ 4319 public static BlogsEntry[] findByC_U_S_PrevAndNext(long entryId, 4320 long companyId, long userId, int status, 4321 OrderByComparator<BlogsEntry> orderByComparator) 4322 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 4323 return getPersistence() 4324 .findByC_U_S_PrevAndNext(entryId, companyId, userId, status, 4325 orderByComparator); 4326 } 4327 4328 /** 4329 * Removes all the blogs entries where companyId = ? and userId = ? and status = ? from the database. 4330 * 4331 * @param companyId the company ID 4332 * @param userId the user ID 4333 * @param status the status 4334 */ 4335 public static void removeByC_U_S(long companyId, long userId, int status) { 4336 getPersistence().removeByC_U_S(companyId, userId, status); 4337 } 4338 4339 /** 4340 * Returns the number of blogs entries where companyId = ? and userId = ? and status = ?. 4341 * 4342 * @param companyId the company ID 4343 * @param userId the user ID 4344 * @param status the status 4345 * @return the number of matching blogs entries 4346 */ 4347 public static int countByC_U_S(long companyId, long userId, int status) { 4348 return getPersistence().countByC_U_S(companyId, userId, status); 4349 } 4350 4351 /** 4352 * Returns all the blogs entries where companyId = ? and userId = ? and status ≠ ?. 4353 * 4354 * @param companyId the company ID 4355 * @param userId the user ID 4356 * @param status the status 4357 * @return the matching blogs entries 4358 */ 4359 public static List<BlogsEntry> findByC_U_NotS(long companyId, long userId, 4360 int status) { 4361 return getPersistence().findByC_U_NotS(companyId, userId, status); 4362 } 4363 4364 /** 4365 * Returns a range of all the blogs entries where companyId = ? and userId = ? and status ≠ ?. 4366 * 4367 * <p> 4368 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4369 * </p> 4370 * 4371 * @param companyId the company ID 4372 * @param userId the user ID 4373 * @param status the status 4374 * @param start the lower bound of the range of blogs entries 4375 * @param end the upper bound of the range of blogs entries (not inclusive) 4376 * @return the range of matching blogs entries 4377 */ 4378 public static List<BlogsEntry> findByC_U_NotS(long companyId, long userId, 4379 int status, int start, int end) { 4380 return getPersistence() 4381 .findByC_U_NotS(companyId, userId, status, start, end); 4382 } 4383 4384 /** 4385 * Returns an ordered range of all the blogs entries where companyId = ? and userId = ? and status ≠ ?. 4386 * 4387 * <p> 4388 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4389 * </p> 4390 * 4391 * @param companyId the company ID 4392 * @param userId the user ID 4393 * @param status the status 4394 * @param start the lower bound of the range of blogs entries 4395 * @param end the upper bound of the range of blogs entries (not inclusive) 4396 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4397 * @return the ordered range of matching blogs entries 4398 */ 4399 public static List<BlogsEntry> findByC_U_NotS(long companyId, long userId, 4400 int status, int start, int end, 4401 OrderByComparator<BlogsEntry> orderByComparator) { 4402 return getPersistence() 4403 .findByC_U_NotS(companyId, userId, status, start, end, 4404 orderByComparator); 4405 } 4406 4407 /** 4408 * Returns an ordered range of all the blogs entries where companyId = ? and userId = ? and status ≠ ?. 4409 * 4410 * <p> 4411 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4412 * </p> 4413 * 4414 * @param companyId the company ID 4415 * @param userId the user ID 4416 * @param status the status 4417 * @param start the lower bound of the range of blogs entries 4418 * @param end the upper bound of the range of blogs entries (not inclusive) 4419 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4420 * @param retrieveFromCache whether to retrieve from the finder cache 4421 * @return the ordered range of matching blogs entries 4422 */ 4423 public static List<BlogsEntry> findByC_U_NotS(long companyId, long userId, 4424 int status, int start, int end, 4425 OrderByComparator<BlogsEntry> orderByComparator, 4426 boolean retrieveFromCache) { 4427 return getPersistence() 4428 .findByC_U_NotS(companyId, userId, status, start, end, 4429 orderByComparator, retrieveFromCache); 4430 } 4431 4432 /** 4433 * Returns the first blogs entry in the ordered set where companyId = ? and userId = ? and status ≠ ?. 4434 * 4435 * @param companyId the company ID 4436 * @param userId the user ID 4437 * @param status the status 4438 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4439 * @return the first matching blogs entry 4440 * @throws NoSuchEntryException if a matching blogs entry could not be found 4441 */ 4442 public static BlogsEntry findByC_U_NotS_First(long companyId, long userId, 4443 int status, OrderByComparator<BlogsEntry> orderByComparator) 4444 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 4445 return getPersistence() 4446 .findByC_U_NotS_First(companyId, userId, status, 4447 orderByComparator); 4448 } 4449 4450 /** 4451 * Returns the first blogs entry in the ordered set where companyId = ? and userId = ? and status ≠ ?. 4452 * 4453 * @param companyId the company ID 4454 * @param userId the user ID 4455 * @param status the status 4456 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4457 * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 4458 */ 4459 public static BlogsEntry fetchByC_U_NotS_First(long companyId, long userId, 4460 int status, OrderByComparator<BlogsEntry> orderByComparator) { 4461 return getPersistence() 4462 .fetchByC_U_NotS_First(companyId, userId, status, 4463 orderByComparator); 4464 } 4465 4466 /** 4467 * Returns the last blogs entry in the ordered set where companyId = ? and userId = ? and status ≠ ?. 4468 * 4469 * @param companyId the company ID 4470 * @param userId the user ID 4471 * @param status the status 4472 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4473 * @return the last matching blogs entry 4474 * @throws NoSuchEntryException if a matching blogs entry could not be found 4475 */ 4476 public static BlogsEntry findByC_U_NotS_Last(long companyId, long userId, 4477 int status, OrderByComparator<BlogsEntry> orderByComparator) 4478 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 4479 return getPersistence() 4480 .findByC_U_NotS_Last(companyId, userId, status, 4481 orderByComparator); 4482 } 4483 4484 /** 4485 * Returns the last blogs entry in the ordered set where companyId = ? and userId = ? and status ≠ ?. 4486 * 4487 * @param companyId the company ID 4488 * @param userId the user ID 4489 * @param status the status 4490 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4491 * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 4492 */ 4493 public static BlogsEntry fetchByC_U_NotS_Last(long companyId, long userId, 4494 int status, OrderByComparator<BlogsEntry> orderByComparator) { 4495 return getPersistence() 4496 .fetchByC_U_NotS_Last(companyId, userId, status, 4497 orderByComparator); 4498 } 4499 4500 /** 4501 * Returns the blogs entries before and after the current blogs entry in the ordered set where companyId = ? and userId = ? and status ≠ ?. 4502 * 4503 * @param entryId the primary key of the current blogs entry 4504 * @param companyId the company ID 4505 * @param userId the user ID 4506 * @param status the status 4507 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4508 * @return the previous, current, and next blogs entry 4509 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 4510 */ 4511 public static BlogsEntry[] findByC_U_NotS_PrevAndNext(long entryId, 4512 long companyId, long userId, int status, 4513 OrderByComparator<BlogsEntry> orderByComparator) 4514 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 4515 return getPersistence() 4516 .findByC_U_NotS_PrevAndNext(entryId, companyId, userId, 4517 status, orderByComparator); 4518 } 4519 4520 /** 4521 * Removes all the blogs entries where companyId = ? and userId = ? and status ≠ ? from the database. 4522 * 4523 * @param companyId the company ID 4524 * @param userId the user ID 4525 * @param status the status 4526 */ 4527 public static void removeByC_U_NotS(long companyId, long userId, int status) { 4528 getPersistence().removeByC_U_NotS(companyId, userId, status); 4529 } 4530 4531 /** 4532 * Returns the number of blogs entries where companyId = ? and userId = ? and status ≠ ?. 4533 * 4534 * @param companyId the company ID 4535 * @param userId the user ID 4536 * @param status the status 4537 * @return the number of matching blogs entries 4538 */ 4539 public static int countByC_U_NotS(long companyId, long userId, int status) { 4540 return getPersistence().countByC_U_NotS(companyId, userId, status); 4541 } 4542 4543 /** 4544 * Returns all the blogs entries where companyId = ? and displayDate < ? and status = ?. 4545 * 4546 * @param companyId the company ID 4547 * @param displayDate the display date 4548 * @param status the status 4549 * @return the matching blogs entries 4550 */ 4551 public static List<BlogsEntry> findByC_LtD_S(long companyId, 4552 Date displayDate, int status) { 4553 return getPersistence().findByC_LtD_S(companyId, displayDate, status); 4554 } 4555 4556 /** 4557 * Returns a range of all the blogs entries where companyId = ? and displayDate < ? and status = ?. 4558 * 4559 * <p> 4560 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4561 * </p> 4562 * 4563 * @param companyId the company ID 4564 * @param displayDate the display date 4565 * @param status the status 4566 * @param start the lower bound of the range of blogs entries 4567 * @param end the upper bound of the range of blogs entries (not inclusive) 4568 * @return the range of matching blogs entries 4569 */ 4570 public static List<BlogsEntry> findByC_LtD_S(long companyId, 4571 Date displayDate, int status, int start, int end) { 4572 return getPersistence() 4573 .findByC_LtD_S(companyId, displayDate, status, start, end); 4574 } 4575 4576 /** 4577 * Returns an ordered range of all the blogs entries where companyId = ? and displayDate < ? and status = ?. 4578 * 4579 * <p> 4580 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4581 * </p> 4582 * 4583 * @param companyId the company ID 4584 * @param displayDate the display date 4585 * @param status the status 4586 * @param start the lower bound of the range of blogs entries 4587 * @param end the upper bound of the range of blogs entries (not inclusive) 4588 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4589 * @return the ordered range of matching blogs entries 4590 */ 4591 public static List<BlogsEntry> findByC_LtD_S(long companyId, 4592 Date displayDate, int status, int start, int end, 4593 OrderByComparator<BlogsEntry> orderByComparator) { 4594 return getPersistence() 4595 .findByC_LtD_S(companyId, displayDate, status, start, end, 4596 orderByComparator); 4597 } 4598 4599 /** 4600 * Returns an ordered range of all the blogs entries where companyId = ? and displayDate < ? and status = ?. 4601 * 4602 * <p> 4603 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4604 * </p> 4605 * 4606 * @param companyId the company ID 4607 * @param displayDate the display date 4608 * @param status the status 4609 * @param start the lower bound of the range of blogs entries 4610 * @param end the upper bound of the range of blogs entries (not inclusive) 4611 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4612 * @param retrieveFromCache whether to retrieve from the finder cache 4613 * @return the ordered range of matching blogs entries 4614 */ 4615 public static List<BlogsEntry> findByC_LtD_S(long companyId, 4616 Date displayDate, int status, int start, int end, 4617 OrderByComparator<BlogsEntry> orderByComparator, 4618 boolean retrieveFromCache) { 4619 return getPersistence() 4620 .findByC_LtD_S(companyId, displayDate, status, start, end, 4621 orderByComparator, retrieveFromCache); 4622 } 4623 4624 /** 4625 * Returns the first blogs entry in the ordered set where companyId = ? and displayDate < ? and status = ?. 4626 * 4627 * @param companyId the company ID 4628 * @param displayDate the display date 4629 * @param status the status 4630 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4631 * @return the first matching blogs entry 4632 * @throws NoSuchEntryException if a matching blogs entry could not be found 4633 */ 4634 public static BlogsEntry findByC_LtD_S_First(long companyId, 4635 Date displayDate, int status, 4636 OrderByComparator<BlogsEntry> orderByComparator) 4637 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 4638 return getPersistence() 4639 .findByC_LtD_S_First(companyId, displayDate, status, 4640 orderByComparator); 4641 } 4642 4643 /** 4644 * Returns the first blogs entry in the ordered set where companyId = ? and displayDate < ? and status = ?. 4645 * 4646 * @param companyId the company ID 4647 * @param displayDate the display date 4648 * @param status the status 4649 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4650 * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 4651 */ 4652 public static BlogsEntry fetchByC_LtD_S_First(long companyId, 4653 Date displayDate, int status, 4654 OrderByComparator<BlogsEntry> orderByComparator) { 4655 return getPersistence() 4656 .fetchByC_LtD_S_First(companyId, displayDate, status, 4657 orderByComparator); 4658 } 4659 4660 /** 4661 * Returns the last blogs entry in the ordered set where companyId = ? and displayDate < ? and status = ?. 4662 * 4663 * @param companyId the company ID 4664 * @param displayDate the display date 4665 * @param status the status 4666 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4667 * @return the last matching blogs entry 4668 * @throws NoSuchEntryException if a matching blogs entry could not be found 4669 */ 4670 public static BlogsEntry findByC_LtD_S_Last(long companyId, 4671 Date displayDate, int status, 4672 OrderByComparator<BlogsEntry> orderByComparator) 4673 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 4674 return getPersistence() 4675 .findByC_LtD_S_Last(companyId, displayDate, status, 4676 orderByComparator); 4677 } 4678 4679 /** 4680 * Returns the last blogs entry in the ordered set where companyId = ? and displayDate < ? and status = ?. 4681 * 4682 * @param companyId the company ID 4683 * @param displayDate the display date 4684 * @param status the status 4685 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4686 * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 4687 */ 4688 public static BlogsEntry fetchByC_LtD_S_Last(long companyId, 4689 Date displayDate, int status, 4690 OrderByComparator<BlogsEntry> orderByComparator) { 4691 return getPersistence() 4692 .fetchByC_LtD_S_Last(companyId, displayDate, status, 4693 orderByComparator); 4694 } 4695 4696 /** 4697 * Returns the blogs entries before and after the current blogs entry in the ordered set where companyId = ? and displayDate < ? and status = ?. 4698 * 4699 * @param entryId the primary key of the current blogs entry 4700 * @param companyId the company ID 4701 * @param displayDate the display date 4702 * @param status the status 4703 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4704 * @return the previous, current, and next blogs entry 4705 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 4706 */ 4707 public static BlogsEntry[] findByC_LtD_S_PrevAndNext(long entryId, 4708 long companyId, Date displayDate, int status, 4709 OrderByComparator<BlogsEntry> orderByComparator) 4710 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 4711 return getPersistence() 4712 .findByC_LtD_S_PrevAndNext(entryId, companyId, displayDate, 4713 status, orderByComparator); 4714 } 4715 4716 /** 4717 * Removes all the blogs entries where companyId = ? and displayDate < ? and status = ? from the database. 4718 * 4719 * @param companyId the company ID 4720 * @param displayDate the display date 4721 * @param status the status 4722 */ 4723 public static void removeByC_LtD_S(long companyId, Date displayDate, 4724 int status) { 4725 getPersistence().removeByC_LtD_S(companyId, displayDate, status); 4726 } 4727 4728 /** 4729 * Returns the number of blogs entries where companyId = ? and displayDate < ? and status = ?. 4730 * 4731 * @param companyId the company ID 4732 * @param displayDate the display date 4733 * @param status the status 4734 * @return the number of matching blogs entries 4735 */ 4736 public static int countByC_LtD_S(long companyId, Date displayDate, 4737 int status) { 4738 return getPersistence().countByC_LtD_S(companyId, displayDate, status); 4739 } 4740 4741 /** 4742 * Returns all the blogs entries where companyId = ? and displayDate < ? and status ≠ ?. 4743 * 4744 * @param companyId the company ID 4745 * @param displayDate the display date 4746 * @param status the status 4747 * @return the matching blogs entries 4748 */ 4749 public static List<BlogsEntry> findByC_LtD_NotS(long companyId, 4750 Date displayDate, int status) { 4751 return getPersistence().findByC_LtD_NotS(companyId, displayDate, status); 4752 } 4753 4754 /** 4755 * Returns a range of all the blogs entries where companyId = ? and displayDate < ? and status ≠ ?. 4756 * 4757 * <p> 4758 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4759 * </p> 4760 * 4761 * @param companyId the company ID 4762 * @param displayDate the display date 4763 * @param status the status 4764 * @param start the lower bound of the range of blogs entries 4765 * @param end the upper bound of the range of blogs entries (not inclusive) 4766 * @return the range of matching blogs entries 4767 */ 4768 public static List<BlogsEntry> findByC_LtD_NotS(long companyId, 4769 Date displayDate, int status, int start, int end) { 4770 return getPersistence() 4771 .findByC_LtD_NotS(companyId, displayDate, status, start, end); 4772 } 4773 4774 /** 4775 * Returns an ordered range of all the blogs entries where companyId = ? and displayDate < ? and status ≠ ?. 4776 * 4777 * <p> 4778 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4779 * </p> 4780 * 4781 * @param companyId the company ID 4782 * @param displayDate the display date 4783 * @param status the status 4784 * @param start the lower bound of the range of blogs entries 4785 * @param end the upper bound of the range of blogs entries (not inclusive) 4786 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4787 * @return the ordered range of matching blogs entries 4788 */ 4789 public static List<BlogsEntry> findByC_LtD_NotS(long companyId, 4790 Date displayDate, int status, int start, int end, 4791 OrderByComparator<BlogsEntry> orderByComparator) { 4792 return getPersistence() 4793 .findByC_LtD_NotS(companyId, displayDate, status, start, 4794 end, orderByComparator); 4795 } 4796 4797 /** 4798 * Returns an ordered range of all the blogs entries where companyId = ? and displayDate < ? and status ≠ ?. 4799 * 4800 * <p> 4801 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4802 * </p> 4803 * 4804 * @param companyId the company ID 4805 * @param displayDate the display date 4806 * @param status the status 4807 * @param start the lower bound of the range of blogs entries 4808 * @param end the upper bound of the range of blogs entries (not inclusive) 4809 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4810 * @param retrieveFromCache whether to retrieve from the finder cache 4811 * @return the ordered range of matching blogs entries 4812 */ 4813 public static List<BlogsEntry> findByC_LtD_NotS(long companyId, 4814 Date displayDate, int status, int start, int end, 4815 OrderByComparator<BlogsEntry> orderByComparator, 4816 boolean retrieveFromCache) { 4817 return getPersistence() 4818 .findByC_LtD_NotS(companyId, displayDate, status, start, 4819 end, orderByComparator, retrieveFromCache); 4820 } 4821 4822 /** 4823 * Returns the first blogs entry in the ordered set where companyId = ? and displayDate < ? and status ≠ ?. 4824 * 4825 * @param companyId the company ID 4826 * @param displayDate the display date 4827 * @param status the status 4828 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4829 * @return the first matching blogs entry 4830 * @throws NoSuchEntryException if a matching blogs entry could not be found 4831 */ 4832 public static BlogsEntry findByC_LtD_NotS_First(long companyId, 4833 Date displayDate, int status, 4834 OrderByComparator<BlogsEntry> orderByComparator) 4835 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 4836 return getPersistence() 4837 .findByC_LtD_NotS_First(companyId, displayDate, status, 4838 orderByComparator); 4839 } 4840 4841 /** 4842 * Returns the first blogs entry in the ordered set where companyId = ? and displayDate < ? and status ≠ ?. 4843 * 4844 * @param companyId the company ID 4845 * @param displayDate the display date 4846 * @param status the status 4847 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4848 * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 4849 */ 4850 public static BlogsEntry fetchByC_LtD_NotS_First(long companyId, 4851 Date displayDate, int status, 4852 OrderByComparator<BlogsEntry> orderByComparator) { 4853 return getPersistence() 4854 .fetchByC_LtD_NotS_First(companyId, displayDate, status, 4855 orderByComparator); 4856 } 4857 4858 /** 4859 * Returns the last blogs entry in the ordered set where companyId = ? and displayDate < ? and status ≠ ?. 4860 * 4861 * @param companyId the company ID 4862 * @param displayDate the display date 4863 * @param status the status 4864 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4865 * @return the last matching blogs entry 4866 * @throws NoSuchEntryException if a matching blogs entry could not be found 4867 */ 4868 public static BlogsEntry findByC_LtD_NotS_Last(long companyId, 4869 Date displayDate, int status, 4870 OrderByComparator<BlogsEntry> orderByComparator) 4871 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 4872 return getPersistence() 4873 .findByC_LtD_NotS_Last(companyId, displayDate, status, 4874 orderByComparator); 4875 } 4876 4877 /** 4878 * Returns the last blogs entry in the ordered set where companyId = ? and displayDate < ? and status ≠ ?. 4879 * 4880 * @param companyId the company ID 4881 * @param displayDate the display date 4882 * @param status the status 4883 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4884 * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 4885 */ 4886 public static BlogsEntry fetchByC_LtD_NotS_Last(long companyId, 4887 Date displayDate, int status, 4888 OrderByComparator<BlogsEntry> orderByComparator) { 4889 return getPersistence() 4890 .fetchByC_LtD_NotS_Last(companyId, displayDate, status, 4891 orderByComparator); 4892 } 4893 4894 /** 4895 * Returns the blogs entries before and after the current blogs entry in the ordered set where companyId = ? and displayDate < ? and status ≠ ?. 4896 * 4897 * @param entryId the primary key of the current blogs entry 4898 * @param companyId the company ID 4899 * @param displayDate the display date 4900 * @param status the status 4901 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 4902 * @return the previous, current, and next blogs entry 4903 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 4904 */ 4905 public static BlogsEntry[] findByC_LtD_NotS_PrevAndNext(long entryId, 4906 long companyId, Date displayDate, int status, 4907 OrderByComparator<BlogsEntry> orderByComparator) 4908 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 4909 return getPersistence() 4910 .findByC_LtD_NotS_PrevAndNext(entryId, companyId, 4911 displayDate, status, orderByComparator); 4912 } 4913 4914 /** 4915 * Removes all the blogs entries where companyId = ? and displayDate < ? and status ≠ ? from the database. 4916 * 4917 * @param companyId the company ID 4918 * @param displayDate the display date 4919 * @param status the status 4920 */ 4921 public static void removeByC_LtD_NotS(long companyId, Date displayDate, 4922 int status) { 4923 getPersistence().removeByC_LtD_NotS(companyId, displayDate, status); 4924 } 4925 4926 /** 4927 * Returns the number of blogs entries where companyId = ? and displayDate < ? and status ≠ ?. 4928 * 4929 * @param companyId the company ID 4930 * @param displayDate the display date 4931 * @param status the status 4932 * @return the number of matching blogs entries 4933 */ 4934 public static int countByC_LtD_NotS(long companyId, Date displayDate, 4935 int status) { 4936 return getPersistence().countByC_LtD_NotS(companyId, displayDate, status); 4937 } 4938 4939 /** 4940 * Returns all the blogs entries where groupId = ? and userId = ? and displayDate < ? and status = ?. 4941 * 4942 * @param groupId the group ID 4943 * @param userId the user ID 4944 * @param displayDate the display date 4945 * @param status the status 4946 * @return the matching blogs entries 4947 */ 4948 public static List<BlogsEntry> findByG_U_LtD_S(long groupId, long userId, 4949 Date displayDate, int status) { 4950 return getPersistence() 4951 .findByG_U_LtD_S(groupId, userId, displayDate, status); 4952 } 4953 4954 /** 4955 * Returns a range of all the blogs entries where groupId = ? and userId = ? and displayDate < ? and status = ?. 4956 * 4957 * <p> 4958 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4959 * </p> 4960 * 4961 * @param groupId the group ID 4962 * @param userId the user ID 4963 * @param displayDate the display date 4964 * @param status the status 4965 * @param start the lower bound of the range of blogs entries 4966 * @param end the upper bound of the range of blogs entries (not inclusive) 4967 * @return the range of matching blogs entries 4968 */ 4969 public static List<BlogsEntry> findByG_U_LtD_S(long groupId, long userId, 4970 Date displayDate, int status, int start, int end) { 4971 return getPersistence() 4972 .findByG_U_LtD_S(groupId, userId, displayDate, status, 4973 start, end); 4974 } 4975 4976 /** 4977 * Returns an ordered range of all the blogs entries where groupId = ? and userId = ? and displayDate < ? and status = ?. 4978 * 4979 * <p> 4980 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 4981 * </p> 4982 * 4983 * @param groupId the group ID 4984 * @param userId the user ID 4985 * @param displayDate the display date 4986 * @param status the status 4987 * @param start the lower bound of the range of blogs entries 4988 * @param end the upper bound of the range of blogs entries (not inclusive) 4989 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 4990 * @return the ordered range of matching blogs entries 4991 */ 4992 public static List<BlogsEntry> findByG_U_LtD_S(long groupId, long userId, 4993 Date displayDate, int status, int start, int end, 4994 OrderByComparator<BlogsEntry> orderByComparator) { 4995 return getPersistence() 4996 .findByG_U_LtD_S(groupId, userId, displayDate, status, 4997 start, end, orderByComparator); 4998 } 4999 5000 /** 5001 * Returns an ordered range of all the blogs entries where groupId = ? and userId = ? and displayDate < ? and status = ?. 5002 * 5003 * <p> 5004 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5005 * </p> 5006 * 5007 * @param groupId the group ID 5008 * @param userId the user ID 5009 * @param displayDate the display date 5010 * @param status the status 5011 * @param start the lower bound of the range of blogs entries 5012 * @param end the upper bound of the range of blogs entries (not inclusive) 5013 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5014 * @param retrieveFromCache whether to retrieve from the finder cache 5015 * @return the ordered range of matching blogs entries 5016 */ 5017 public static List<BlogsEntry> findByG_U_LtD_S(long groupId, long userId, 5018 Date displayDate, int status, int start, int end, 5019 OrderByComparator<BlogsEntry> orderByComparator, 5020 boolean retrieveFromCache) { 5021 return getPersistence() 5022 .findByG_U_LtD_S(groupId, userId, displayDate, status, 5023 start, end, orderByComparator, retrieveFromCache); 5024 } 5025 5026 /** 5027 * Returns the first blogs entry in the ordered set where groupId = ? and userId = ? and displayDate < ? and status = ?. 5028 * 5029 * @param groupId the group ID 5030 * @param userId the user ID 5031 * @param displayDate the display date 5032 * @param status the status 5033 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5034 * @return the first matching blogs entry 5035 * @throws NoSuchEntryException if a matching blogs entry could not be found 5036 */ 5037 public static BlogsEntry findByG_U_LtD_S_First(long groupId, long userId, 5038 Date displayDate, int status, 5039 OrderByComparator<BlogsEntry> orderByComparator) 5040 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 5041 return getPersistence() 5042 .findByG_U_LtD_S_First(groupId, userId, displayDate, status, 5043 orderByComparator); 5044 } 5045 5046 /** 5047 * Returns the first blogs entry in the ordered set where groupId = ? and userId = ? and displayDate < ? and status = ?. 5048 * 5049 * @param groupId the group ID 5050 * @param userId the user ID 5051 * @param displayDate the display date 5052 * @param status the status 5053 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5054 * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 5055 */ 5056 public static BlogsEntry fetchByG_U_LtD_S_First(long groupId, long userId, 5057 Date displayDate, int status, 5058 OrderByComparator<BlogsEntry> orderByComparator) { 5059 return getPersistence() 5060 .fetchByG_U_LtD_S_First(groupId, userId, displayDate, 5061 status, orderByComparator); 5062 } 5063 5064 /** 5065 * Returns the last blogs entry in the ordered set where groupId = ? and userId = ? and displayDate < ? and status = ?. 5066 * 5067 * @param groupId the group ID 5068 * @param userId the user ID 5069 * @param displayDate the display date 5070 * @param status the status 5071 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5072 * @return the last matching blogs entry 5073 * @throws NoSuchEntryException if a matching blogs entry could not be found 5074 */ 5075 public static BlogsEntry findByG_U_LtD_S_Last(long groupId, long userId, 5076 Date displayDate, int status, 5077 OrderByComparator<BlogsEntry> orderByComparator) 5078 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 5079 return getPersistence() 5080 .findByG_U_LtD_S_Last(groupId, userId, displayDate, status, 5081 orderByComparator); 5082 } 5083 5084 /** 5085 * Returns the last blogs entry in the ordered set where groupId = ? and userId = ? and displayDate < ? and status = ?. 5086 * 5087 * @param groupId the group ID 5088 * @param userId the user ID 5089 * @param displayDate the display date 5090 * @param status the status 5091 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5092 * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 5093 */ 5094 public static BlogsEntry fetchByG_U_LtD_S_Last(long groupId, long userId, 5095 Date displayDate, int status, 5096 OrderByComparator<BlogsEntry> orderByComparator) { 5097 return getPersistence() 5098 .fetchByG_U_LtD_S_Last(groupId, userId, displayDate, status, 5099 orderByComparator); 5100 } 5101 5102 /** 5103 * Returns the blogs entries before and after the current blogs entry in the ordered set where groupId = ? and userId = ? and displayDate < ? and status = ?. 5104 * 5105 * @param entryId the primary key of the current blogs entry 5106 * @param groupId the group ID 5107 * @param userId the user ID 5108 * @param displayDate the display date 5109 * @param status the status 5110 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5111 * @return the previous, current, and next blogs entry 5112 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 5113 */ 5114 public static BlogsEntry[] findByG_U_LtD_S_PrevAndNext(long entryId, 5115 long groupId, long userId, Date displayDate, int status, 5116 OrderByComparator<BlogsEntry> orderByComparator) 5117 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 5118 return getPersistence() 5119 .findByG_U_LtD_S_PrevAndNext(entryId, groupId, userId, 5120 displayDate, status, orderByComparator); 5121 } 5122 5123 /** 5124 * Returns all the blogs entries that the user has permission to view where groupId = ? and userId = ? and displayDate < ? and status = ?. 5125 * 5126 * @param groupId the group ID 5127 * @param userId the user ID 5128 * @param displayDate the display date 5129 * @param status the status 5130 * @return the matching blogs entries that the user has permission to view 5131 */ 5132 public static List<BlogsEntry> filterFindByG_U_LtD_S(long groupId, 5133 long userId, Date displayDate, int status) { 5134 return getPersistence() 5135 .filterFindByG_U_LtD_S(groupId, userId, displayDate, status); 5136 } 5137 5138 /** 5139 * Returns a range of all the blogs entries that the user has permission to view where groupId = ? and userId = ? and displayDate < ? and status = ?. 5140 * 5141 * <p> 5142 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5143 * </p> 5144 * 5145 * @param groupId the group ID 5146 * @param userId the user ID 5147 * @param displayDate the display date 5148 * @param status the status 5149 * @param start the lower bound of the range of blogs entries 5150 * @param end the upper bound of the range of blogs entries (not inclusive) 5151 * @return the range of matching blogs entries that the user has permission to view 5152 */ 5153 public static List<BlogsEntry> filterFindByG_U_LtD_S(long groupId, 5154 long userId, Date displayDate, int status, int start, int end) { 5155 return getPersistence() 5156 .filterFindByG_U_LtD_S(groupId, userId, displayDate, status, 5157 start, end); 5158 } 5159 5160 /** 5161 * Returns an ordered range of all the blogs entries that the user has permissions to view where groupId = ? and userId = ? and displayDate < ? and status = ?. 5162 * 5163 * <p> 5164 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5165 * </p> 5166 * 5167 * @param groupId the group ID 5168 * @param userId the user ID 5169 * @param displayDate the display date 5170 * @param status the status 5171 * @param start the lower bound of the range of blogs entries 5172 * @param end the upper bound of the range of blogs entries (not inclusive) 5173 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5174 * @return the ordered range of matching blogs entries that the user has permission to view 5175 */ 5176 public static List<BlogsEntry> filterFindByG_U_LtD_S(long groupId, 5177 long userId, Date displayDate, int status, int start, int end, 5178 OrderByComparator<BlogsEntry> orderByComparator) { 5179 return getPersistence() 5180 .filterFindByG_U_LtD_S(groupId, userId, displayDate, status, 5181 start, end, orderByComparator); 5182 } 5183 5184 /** 5185 * 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 = ?. 5186 * 5187 * @param entryId the primary key of the current blogs entry 5188 * @param groupId the group ID 5189 * @param userId the user ID 5190 * @param displayDate the display date 5191 * @param status the status 5192 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5193 * @return the previous, current, and next blogs entry 5194 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 5195 */ 5196 public static BlogsEntry[] filterFindByG_U_LtD_S_PrevAndNext(long entryId, 5197 long groupId, long userId, Date displayDate, int status, 5198 OrderByComparator<BlogsEntry> orderByComparator) 5199 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 5200 return getPersistence() 5201 .filterFindByG_U_LtD_S_PrevAndNext(entryId, groupId, userId, 5202 displayDate, status, orderByComparator); 5203 } 5204 5205 /** 5206 * Removes all the blogs entries where groupId = ? and userId = ? and displayDate < ? and status = ? from the database. 5207 * 5208 * @param groupId the group ID 5209 * @param userId the user ID 5210 * @param displayDate the display date 5211 * @param status the status 5212 */ 5213 public static void removeByG_U_LtD_S(long groupId, long userId, 5214 Date displayDate, int status) { 5215 getPersistence().removeByG_U_LtD_S(groupId, userId, displayDate, status); 5216 } 5217 5218 /** 5219 * Returns the number of blogs entries where groupId = ? and userId = ? and displayDate < ? and status = ?. 5220 * 5221 * @param groupId the group ID 5222 * @param userId the user ID 5223 * @param displayDate the display date 5224 * @param status the status 5225 * @return the number of matching blogs entries 5226 */ 5227 public static int countByG_U_LtD_S(long groupId, long userId, 5228 Date displayDate, int status) { 5229 return getPersistence() 5230 .countByG_U_LtD_S(groupId, userId, displayDate, status); 5231 } 5232 5233 /** 5234 * Returns the number of blogs entries that the user has permission to view where groupId = ? and userId = ? and displayDate < ? and status = ?. 5235 * 5236 * @param groupId the group ID 5237 * @param userId the user ID 5238 * @param displayDate the display date 5239 * @param status the status 5240 * @return the number of matching blogs entries that the user has permission to view 5241 */ 5242 public static int filterCountByG_U_LtD_S(long groupId, long userId, 5243 Date displayDate, int status) { 5244 return getPersistence() 5245 .filterCountByG_U_LtD_S(groupId, userId, displayDate, status); 5246 } 5247 5248 /** 5249 * Returns all the blogs entries where groupId = ? and userId = ? and displayDate < ? and status ≠ ?. 5250 * 5251 * @param groupId the group ID 5252 * @param userId the user ID 5253 * @param displayDate the display date 5254 * @param status the status 5255 * @return the matching blogs entries 5256 */ 5257 public static List<BlogsEntry> findByG_U_LtD_NotS(long groupId, 5258 long userId, Date displayDate, int status) { 5259 return getPersistence() 5260 .findByG_U_LtD_NotS(groupId, userId, displayDate, status); 5261 } 5262 5263 /** 5264 * Returns a range of all the blogs entries where groupId = ? and userId = ? and displayDate < ? and status ≠ ?. 5265 * 5266 * <p> 5267 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5268 * </p> 5269 * 5270 * @param groupId the group ID 5271 * @param userId the user ID 5272 * @param displayDate the display date 5273 * @param status the status 5274 * @param start the lower bound of the range of blogs entries 5275 * @param end the upper bound of the range of blogs entries (not inclusive) 5276 * @return the range of matching blogs entries 5277 */ 5278 public static List<BlogsEntry> findByG_U_LtD_NotS(long groupId, 5279 long userId, Date displayDate, int status, int start, int end) { 5280 return getPersistence() 5281 .findByG_U_LtD_NotS(groupId, userId, displayDate, status, 5282 start, end); 5283 } 5284 5285 /** 5286 * Returns an ordered range of all the blogs entries where groupId = ? and userId = ? and displayDate < ? and status ≠ ?. 5287 * 5288 * <p> 5289 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5290 * </p> 5291 * 5292 * @param groupId the group ID 5293 * @param userId the user ID 5294 * @param displayDate the display date 5295 * @param status the status 5296 * @param start the lower bound of the range of blogs entries 5297 * @param end the upper bound of the range of blogs entries (not inclusive) 5298 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5299 * @return the ordered range of matching blogs entries 5300 */ 5301 public static List<BlogsEntry> findByG_U_LtD_NotS(long groupId, 5302 long userId, Date displayDate, int status, int start, int end, 5303 OrderByComparator<BlogsEntry> orderByComparator) { 5304 return getPersistence() 5305 .findByG_U_LtD_NotS(groupId, userId, displayDate, status, 5306 start, end, orderByComparator); 5307 } 5308 5309 /** 5310 * Returns an ordered range of all the blogs entries where groupId = ? and userId = ? and displayDate < ? and status ≠ ?. 5311 * 5312 * <p> 5313 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5314 * </p> 5315 * 5316 * @param groupId the group ID 5317 * @param userId the user ID 5318 * @param displayDate the display date 5319 * @param status the status 5320 * @param start the lower bound of the range of blogs entries 5321 * @param end the upper bound of the range of blogs entries (not inclusive) 5322 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5323 * @param retrieveFromCache whether to retrieve from the finder cache 5324 * @return the ordered range of matching blogs entries 5325 */ 5326 public static List<BlogsEntry> findByG_U_LtD_NotS(long groupId, 5327 long userId, Date displayDate, int status, int start, int end, 5328 OrderByComparator<BlogsEntry> orderByComparator, 5329 boolean retrieveFromCache) { 5330 return getPersistence() 5331 .findByG_U_LtD_NotS(groupId, userId, displayDate, status, 5332 start, end, orderByComparator, retrieveFromCache); 5333 } 5334 5335 /** 5336 * Returns the first blogs entry in the ordered set where groupId = ? and userId = ? and displayDate < ? and status ≠ ?. 5337 * 5338 * @param groupId the group ID 5339 * @param userId the user ID 5340 * @param displayDate the display date 5341 * @param status the status 5342 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5343 * @return the first matching blogs entry 5344 * @throws NoSuchEntryException if a matching blogs entry could not be found 5345 */ 5346 public static BlogsEntry findByG_U_LtD_NotS_First(long groupId, 5347 long userId, Date displayDate, int status, 5348 OrderByComparator<BlogsEntry> orderByComparator) 5349 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 5350 return getPersistence() 5351 .findByG_U_LtD_NotS_First(groupId, userId, displayDate, 5352 status, orderByComparator); 5353 } 5354 5355 /** 5356 * Returns the first blogs entry in the ordered set where groupId = ? and userId = ? and displayDate < ? and status ≠ ?. 5357 * 5358 * @param groupId the group ID 5359 * @param userId the user ID 5360 * @param displayDate the display date 5361 * @param status the status 5362 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5363 * @return the first matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 5364 */ 5365 public static BlogsEntry fetchByG_U_LtD_NotS_First(long groupId, 5366 long userId, Date displayDate, int status, 5367 OrderByComparator<BlogsEntry> orderByComparator) { 5368 return getPersistence() 5369 .fetchByG_U_LtD_NotS_First(groupId, userId, displayDate, 5370 status, orderByComparator); 5371 } 5372 5373 /** 5374 * Returns the last blogs entry in the ordered set where groupId = ? and userId = ? and displayDate < ? and status ≠ ?. 5375 * 5376 * @param groupId the group ID 5377 * @param userId the user ID 5378 * @param displayDate the display date 5379 * @param status the status 5380 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5381 * @return the last matching blogs entry 5382 * @throws NoSuchEntryException if a matching blogs entry could not be found 5383 */ 5384 public static BlogsEntry findByG_U_LtD_NotS_Last(long groupId, long userId, 5385 Date displayDate, int status, 5386 OrderByComparator<BlogsEntry> orderByComparator) 5387 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 5388 return getPersistence() 5389 .findByG_U_LtD_NotS_Last(groupId, userId, displayDate, 5390 status, orderByComparator); 5391 } 5392 5393 /** 5394 * Returns the last blogs entry in the ordered set where groupId = ? and userId = ? and displayDate < ? and status ≠ ?. 5395 * 5396 * @param groupId the group ID 5397 * @param userId the user ID 5398 * @param displayDate the display date 5399 * @param status the status 5400 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5401 * @return the last matching blogs entry, or <code>null</code> if a matching blogs entry could not be found 5402 */ 5403 public static BlogsEntry fetchByG_U_LtD_NotS_Last(long groupId, 5404 long userId, Date displayDate, int status, 5405 OrderByComparator<BlogsEntry> orderByComparator) { 5406 return getPersistence() 5407 .fetchByG_U_LtD_NotS_Last(groupId, userId, displayDate, 5408 status, orderByComparator); 5409 } 5410 5411 /** 5412 * Returns the blogs entries before and after the current blogs entry in the ordered set where groupId = ? and userId = ? and displayDate < ? and status ≠ ?. 5413 * 5414 * @param entryId the primary key of the current blogs entry 5415 * @param groupId the group ID 5416 * @param userId the user ID 5417 * @param displayDate the display date 5418 * @param status the status 5419 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5420 * @return the previous, current, and next blogs entry 5421 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 5422 */ 5423 public static BlogsEntry[] findByG_U_LtD_NotS_PrevAndNext(long entryId, 5424 long groupId, long userId, Date displayDate, int status, 5425 OrderByComparator<BlogsEntry> orderByComparator) 5426 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 5427 return getPersistence() 5428 .findByG_U_LtD_NotS_PrevAndNext(entryId, groupId, userId, 5429 displayDate, status, orderByComparator); 5430 } 5431 5432 /** 5433 * Returns all the blogs entries that the user has permission to view where groupId = ? and userId = ? and displayDate < ? and status ≠ ?. 5434 * 5435 * @param groupId the group ID 5436 * @param userId the user ID 5437 * @param displayDate the display date 5438 * @param status the status 5439 * @return the matching blogs entries that the user has permission to view 5440 */ 5441 public static List<BlogsEntry> filterFindByG_U_LtD_NotS(long groupId, 5442 long userId, Date displayDate, int status) { 5443 return getPersistence() 5444 .filterFindByG_U_LtD_NotS(groupId, userId, displayDate, 5445 status); 5446 } 5447 5448 /** 5449 * Returns a range of all the blogs entries that the user has permission to view where groupId = ? and userId = ? and displayDate < ? and status ≠ ?. 5450 * 5451 * <p> 5452 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5453 * </p> 5454 * 5455 * @param groupId the group ID 5456 * @param userId the user ID 5457 * @param displayDate the display date 5458 * @param status the status 5459 * @param start the lower bound of the range of blogs entries 5460 * @param end the upper bound of the range of blogs entries (not inclusive) 5461 * @return the range of matching blogs entries that the user has permission to view 5462 */ 5463 public static List<BlogsEntry> filterFindByG_U_LtD_NotS(long groupId, 5464 long userId, Date displayDate, int status, int start, int end) { 5465 return getPersistence() 5466 .filterFindByG_U_LtD_NotS(groupId, userId, displayDate, 5467 status, start, end); 5468 } 5469 5470 /** 5471 * Returns an ordered range of all the blogs entries that the user has permissions to view where groupId = ? and userId = ? and displayDate < ? and status ≠ ?. 5472 * 5473 * <p> 5474 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5475 * </p> 5476 * 5477 * @param groupId the group ID 5478 * @param userId the user ID 5479 * @param displayDate the display date 5480 * @param status the status 5481 * @param start the lower bound of the range of blogs entries 5482 * @param end the upper bound of the range of blogs entries (not inclusive) 5483 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5484 * @return the ordered range of matching blogs entries that the user has permission to view 5485 */ 5486 public static List<BlogsEntry> filterFindByG_U_LtD_NotS(long groupId, 5487 long userId, Date displayDate, int status, int start, int end, 5488 OrderByComparator<BlogsEntry> orderByComparator) { 5489 return getPersistence() 5490 .filterFindByG_U_LtD_NotS(groupId, userId, displayDate, 5491 status, start, end, orderByComparator); 5492 } 5493 5494 /** 5495 * 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 ≠ ?. 5496 * 5497 * @param entryId the primary key of the current blogs entry 5498 * @param groupId the group ID 5499 * @param userId the user ID 5500 * @param displayDate the display date 5501 * @param status the status 5502 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 5503 * @return the previous, current, and next blogs entry 5504 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 5505 */ 5506 public static BlogsEntry[] filterFindByG_U_LtD_NotS_PrevAndNext( 5507 long entryId, long groupId, long userId, Date displayDate, int status, 5508 OrderByComparator<BlogsEntry> orderByComparator) 5509 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 5510 return getPersistence() 5511 .filterFindByG_U_LtD_NotS_PrevAndNext(entryId, groupId, 5512 userId, displayDate, status, orderByComparator); 5513 } 5514 5515 /** 5516 * Removes all the blogs entries where groupId = ? and userId = ? and displayDate < ? and status ≠ ? from the database. 5517 * 5518 * @param groupId the group ID 5519 * @param userId the user ID 5520 * @param displayDate the display date 5521 * @param status the status 5522 */ 5523 public static void removeByG_U_LtD_NotS(long groupId, long userId, 5524 Date displayDate, int status) { 5525 getPersistence() 5526 .removeByG_U_LtD_NotS(groupId, userId, displayDate, status); 5527 } 5528 5529 /** 5530 * Returns the number of blogs entries where groupId = ? and userId = ? and displayDate < ? and status ≠ ?. 5531 * 5532 * @param groupId the group ID 5533 * @param userId the user ID 5534 * @param displayDate the display date 5535 * @param status the status 5536 * @return the number of matching blogs entries 5537 */ 5538 public static int countByG_U_LtD_NotS(long groupId, long userId, 5539 Date displayDate, int status) { 5540 return getPersistence() 5541 .countByG_U_LtD_NotS(groupId, userId, displayDate, status); 5542 } 5543 5544 /** 5545 * Returns the number of blogs entries that the user has permission to view where groupId = ? and userId = ? and displayDate < ? and status ≠ ?. 5546 * 5547 * @param groupId the group ID 5548 * @param userId the user ID 5549 * @param displayDate the display date 5550 * @param status the status 5551 * @return the number of matching blogs entries that the user has permission to view 5552 */ 5553 public static int filterCountByG_U_LtD_NotS(long groupId, long userId, 5554 Date displayDate, int status) { 5555 return getPersistence() 5556 .filterCountByG_U_LtD_NotS(groupId, userId, displayDate, 5557 status); 5558 } 5559 5560 /** 5561 * Caches the blogs entry in the entity cache if it is enabled. 5562 * 5563 * @param blogsEntry the blogs entry 5564 */ 5565 public static void cacheResult(BlogsEntry blogsEntry) { 5566 getPersistence().cacheResult(blogsEntry); 5567 } 5568 5569 /** 5570 * Caches the blogs entries in the entity cache if it is enabled. 5571 * 5572 * @param blogsEntries the blogs entries 5573 */ 5574 public static void cacheResult(List<BlogsEntry> blogsEntries) { 5575 getPersistence().cacheResult(blogsEntries); 5576 } 5577 5578 /** 5579 * Creates a new blogs entry with the primary key. Does not add the blogs entry to the database. 5580 * 5581 * @param entryId the primary key for the new blogs entry 5582 * @return the new blogs entry 5583 */ 5584 public static BlogsEntry create(long entryId) { 5585 return getPersistence().create(entryId); 5586 } 5587 5588 /** 5589 * Removes the blogs entry with the primary key from the database. Also notifies the appropriate model listeners. 5590 * 5591 * @param entryId the primary key of the blogs entry 5592 * @return the blogs entry that was removed 5593 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 5594 */ 5595 public static BlogsEntry remove(long entryId) 5596 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 5597 return getPersistence().remove(entryId); 5598 } 5599 5600 public static BlogsEntry updateImpl(BlogsEntry blogsEntry) { 5601 return getPersistence().updateImpl(blogsEntry); 5602 } 5603 5604 /** 5605 * Returns the blogs entry with the primary key or throws a {@link NoSuchEntryException} if it could not be found. 5606 * 5607 * @param entryId the primary key of the blogs entry 5608 * @return the blogs entry 5609 * @throws NoSuchEntryException if a blogs entry with the primary key could not be found 5610 */ 5611 public static BlogsEntry findByPrimaryKey(long entryId) 5612 throws com.liferay.portlet.blogs.exception.NoSuchEntryException { 5613 return getPersistence().findByPrimaryKey(entryId); 5614 } 5615 5616 /** 5617 * Returns the blogs entry with the primary key or returns <code>null</code> if it could not be found. 5618 * 5619 * @param entryId the primary key of the blogs entry 5620 * @return the blogs entry, or <code>null</code> if a blogs entry with the primary key could not be found 5621 */ 5622 public static BlogsEntry fetchByPrimaryKey(long entryId) { 5623 return getPersistence().fetchByPrimaryKey(entryId); 5624 } 5625 5626 public static java.util.Map<java.io.Serializable, BlogsEntry> fetchByPrimaryKeys( 5627 java.util.Set<java.io.Serializable> primaryKeys) { 5628 return getPersistence().fetchByPrimaryKeys(primaryKeys); 5629 } 5630 5631 /** 5632 * Returns all the blogs entries. 5633 * 5634 * @return the blogs entries 5635 */ 5636 public static List<BlogsEntry> findAll() { 5637 return getPersistence().findAll(); 5638 } 5639 5640 /** 5641 * Returns a range of all the blogs entries. 5642 * 5643 * <p> 5644 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5645 * </p> 5646 * 5647 * @param start the lower bound of the range of blogs entries 5648 * @param end the upper bound of the range of blogs entries (not inclusive) 5649 * @return the range of blogs entries 5650 */ 5651 public static List<BlogsEntry> findAll(int start, int end) { 5652 return getPersistence().findAll(start, end); 5653 } 5654 5655 /** 5656 * Returns an ordered range of all the blogs entries. 5657 * 5658 * <p> 5659 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5660 * </p> 5661 * 5662 * @param start the lower bound of the range of blogs entries 5663 * @param end the upper bound of the range of blogs entries (not inclusive) 5664 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5665 * @return the ordered range of blogs entries 5666 */ 5667 public static List<BlogsEntry> findAll(int start, int end, 5668 OrderByComparator<BlogsEntry> orderByComparator) { 5669 return getPersistence().findAll(start, end, orderByComparator); 5670 } 5671 5672 /** 5673 * Returns an ordered range of all the blogs entries. 5674 * 5675 * <p> 5676 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link BlogsEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 5677 * </p> 5678 * 5679 * @param start the lower bound of the range of blogs entries 5680 * @param end the upper bound of the range of blogs entries (not inclusive) 5681 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 5682 * @param retrieveFromCache whether to retrieve from the finder cache 5683 * @return the ordered range of blogs entries 5684 */ 5685 public static List<BlogsEntry> findAll(int start, int end, 5686 OrderByComparator<BlogsEntry> orderByComparator, 5687 boolean retrieveFromCache) { 5688 return getPersistence() 5689 .findAll(start, end, orderByComparator, retrieveFromCache); 5690 } 5691 5692 /** 5693 * Removes all the blogs entries from the database. 5694 */ 5695 public static void removeAll() { 5696 getPersistence().removeAll(); 5697 } 5698 5699 /** 5700 * Returns the number of blogs entries. 5701 * 5702 * @return the number of blogs entries 5703 */ 5704 public static int countAll() { 5705 return getPersistence().countAll(); 5706 } 5707 5708 public static java.util.Set<java.lang.String> getBadColumnNames() { 5709 return getPersistence().getBadColumnNames(); 5710 } 5711 5712 public static BlogsEntryPersistence getPersistence() { 5713 if (_persistence == null) { 5714 _persistence = (BlogsEntryPersistence)PortalBeanLocatorUtil.locate(BlogsEntryPersistence.class.getName()); 5715 5716 ReferenceRegistry.registerReference(BlogsEntryUtil.class, 5717 "_persistence"); 5718 } 5719 5720 return _persistence; 5721 } 5722 5723 private static BlogsEntryPersistence _persistence; 5724 }