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