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