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