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