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