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