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