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