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.journal.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.service.persistence.BasePersistence; 020 021 import com.liferay.portlet.journal.model.JournalFolder; 022 023 /** 024 * The persistence interface for the journal folder 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.journal.service.persistence.impl.JournalFolderPersistenceImpl 032 * @see JournalFolderUtil 033 * @generated 034 */ 035 @ProviderType 036 public interface JournalFolderPersistence extends BasePersistence<JournalFolder> { 037 /* 038 * NOTE FOR DEVELOPERS: 039 * 040 * Never modify or reference this interface directly. Always use {@link JournalFolderUtil} to access the journal folder persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface. 041 */ 042 043 /** 044 * Returns all the journal folders where uuid = ?. 045 * 046 * @param uuid the uuid 047 * @return the matching journal folders 048 */ 049 public java.util.List<JournalFolder> findByUuid(java.lang.String uuid); 050 051 /** 052 * Returns a range of all the journal folders 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 JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query 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 journal folders 060 * @param end the upper bound of the range of journal folders (not inclusive) 061 * @return the range of matching journal folders 062 */ 063 public java.util.List<JournalFolder> findByUuid(java.lang.String uuid, 064 int start, int end); 065 066 /** 067 * Returns an ordered range of all the journal folders 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 JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query 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 journal folders 075 * @param end the upper bound of the range of journal folders (not inclusive) 076 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 077 * @return the ordered range of matching journal folders 078 */ 079 public java.util.List<JournalFolder> findByUuid(java.lang.String uuid, 080 int start, int end, 081 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator); 082 083 /** 084 * Returns the first journal folder 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 journal folder 089 * @throws NoSuchFolderException if a matching journal folder could not be found 090 */ 091 public JournalFolder findByUuid_First(java.lang.String uuid, 092 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator) 093 throws com.liferay.portlet.journal.NoSuchFolderException; 094 095 /** 096 * Returns the first journal folder 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 journal folder, or <code>null</code> if a matching journal folder could not be found 101 */ 102 public JournalFolder fetchByUuid_First(java.lang.String uuid, 103 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator); 104 105 /** 106 * Returns the last journal folder 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 journal folder 111 * @throws NoSuchFolderException if a matching journal folder could not be found 112 */ 113 public JournalFolder findByUuid_Last(java.lang.String uuid, 114 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator) 115 throws com.liferay.portlet.journal.NoSuchFolderException; 116 117 /** 118 * Returns the last journal folder 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 journal folder, or <code>null</code> if a matching journal folder could not be found 123 */ 124 public JournalFolder fetchByUuid_Last(java.lang.String uuid, 125 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator); 126 127 /** 128 * Returns the journal folders before and after the current journal folder in the ordered set where uuid = ?. 129 * 130 * @param folderId the primary key of the current journal folder 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 journal folder 134 * @throws NoSuchFolderException if a journal folder with the primary key could not be found 135 */ 136 public JournalFolder[] findByUuid_PrevAndNext(long folderId, 137 java.lang.String uuid, 138 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator) 139 throws com.liferay.portlet.journal.NoSuchFolderException; 140 141 /** 142 * Removes all the journal folders 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 journal folders where uuid = ?. 150 * 151 * @param uuid the uuid 152 * @return the number of matching journal folders 153 */ 154 public int countByUuid(java.lang.String uuid); 155 156 /** 157 * Returns the journal folder where uuid = ? and groupId = ? or throws a {@link NoSuchFolderException} if it could not be found. 158 * 159 * @param uuid the uuid 160 * @param groupId the group ID 161 * @return the matching journal folder 162 * @throws NoSuchFolderException if a matching journal folder could not be found 163 */ 164 public JournalFolder findByUUID_G(java.lang.String uuid, long groupId) 165 throws com.liferay.portlet.journal.NoSuchFolderException; 166 167 /** 168 * Returns the journal folder 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 journal folder, or <code>null</code> if a matching journal folder could not be found 173 */ 174 public JournalFolder fetchByUUID_G(java.lang.String uuid, long groupId); 175 176 /** 177 * Returns the journal folder 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 journal folder, or <code>null</code> if a matching journal folder could not be found 183 */ 184 public JournalFolder fetchByUUID_G(java.lang.String uuid, long groupId, 185 boolean retrieveFromCache); 186 187 /** 188 * Removes the journal folder where uuid = ? and groupId = ? from the database. 189 * 190 * @param uuid the uuid 191 * @param groupId the group ID 192 * @return the journal folder that was removed 193 */ 194 public JournalFolder removeByUUID_G(java.lang.String uuid, long groupId) 195 throws com.liferay.portlet.journal.NoSuchFolderException; 196 197 /** 198 * Returns the number of journal folders where uuid = ? and groupId = ?. 199 * 200 * @param uuid the uuid 201 * @param groupId the group ID 202 * @return the number of matching journal folders 203 */ 204 public int countByUUID_G(java.lang.String uuid, long groupId); 205 206 /** 207 * Returns all the journal folders where uuid = ? and companyId = ?. 208 * 209 * @param uuid the uuid 210 * @param companyId the company ID 211 * @return the matching journal folders 212 */ 213 public java.util.List<JournalFolder> findByUuid_C(java.lang.String uuid, 214 long companyId); 215 216 /** 217 * Returns a range of all the journal folders 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 JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query 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 journal folders 226 * @param end the upper bound of the range of journal folders (not inclusive) 227 * @return the range of matching journal folders 228 */ 229 public java.util.List<JournalFolder> findByUuid_C(java.lang.String uuid, 230 long companyId, int start, int end); 231 232 /** 233 * Returns an ordered range of all the journal folders 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 JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query 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 journal folders 242 * @param end the upper bound of the range of journal folders (not inclusive) 243 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 244 * @return the ordered range of matching journal folders 245 */ 246 public java.util.List<JournalFolder> findByUuid_C(java.lang.String uuid, 247 long companyId, int start, int end, 248 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator); 249 250 /** 251 * Returns the first journal folder 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 journal folder 257 * @throws NoSuchFolderException if a matching journal folder could not be found 258 */ 259 public JournalFolder findByUuid_C_First(java.lang.String uuid, 260 long companyId, 261 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator) 262 throws com.liferay.portlet.journal.NoSuchFolderException; 263 264 /** 265 * Returns the first journal folder in the ordered set where uuid = ? and companyId = ?. 266 * 267 * @param uuid the uuid 268 * @param companyId the company ID 269 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 270 * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found 271 */ 272 public JournalFolder fetchByUuid_C_First(java.lang.String uuid, 273 long companyId, 274 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator); 275 276 /** 277 * Returns the last journal folder in the ordered set where uuid = ? and companyId = ?. 278 * 279 * @param uuid the uuid 280 * @param companyId the company ID 281 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 282 * @return the last matching journal folder 283 * @throws NoSuchFolderException if a matching journal folder could not be found 284 */ 285 public JournalFolder findByUuid_C_Last(java.lang.String uuid, 286 long companyId, 287 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator) 288 throws com.liferay.portlet.journal.NoSuchFolderException; 289 290 /** 291 * Returns the last journal folder in the ordered set where uuid = ? and companyId = ?. 292 * 293 * @param uuid the uuid 294 * @param companyId the company ID 295 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 296 * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found 297 */ 298 public JournalFolder fetchByUuid_C_Last(java.lang.String uuid, 299 long companyId, 300 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator); 301 302 /** 303 * Returns the journal folders before and after the current journal folder in the ordered set where uuid = ? and companyId = ?. 304 * 305 * @param folderId the primary key of the current journal folder 306 * @param uuid the uuid 307 * @param companyId the company ID 308 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 309 * @return the previous, current, and next journal folder 310 * @throws NoSuchFolderException if a journal folder with the primary key could not be found 311 */ 312 public JournalFolder[] findByUuid_C_PrevAndNext(long folderId, 313 java.lang.String uuid, long companyId, 314 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator) 315 throws com.liferay.portlet.journal.NoSuchFolderException; 316 317 /** 318 * Removes all the journal folders where uuid = ? and companyId = ? from the database. 319 * 320 * @param uuid the uuid 321 * @param companyId the company ID 322 */ 323 public void removeByUuid_C(java.lang.String uuid, long companyId); 324 325 /** 326 * Returns the number of journal folders where uuid = ? and companyId = ?. 327 * 328 * @param uuid the uuid 329 * @param companyId the company ID 330 * @return the number of matching journal folders 331 */ 332 public int countByUuid_C(java.lang.String uuid, long companyId); 333 334 /** 335 * Returns all the journal folders where groupId = ?. 336 * 337 * @param groupId the group ID 338 * @return the matching journal folders 339 */ 340 public java.util.List<JournalFolder> findByGroupId(long groupId); 341 342 /** 343 * Returns a range of all the journal folders where groupId = ?. 344 * 345 * <p> 346 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 347 * </p> 348 * 349 * @param groupId the group ID 350 * @param start the lower bound of the range of journal folders 351 * @param end the upper bound of the range of journal folders (not inclusive) 352 * @return the range of matching journal folders 353 */ 354 public java.util.List<JournalFolder> findByGroupId(long groupId, int start, 355 int end); 356 357 /** 358 * Returns an ordered range of all the journal folders where groupId = ?. 359 * 360 * <p> 361 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 362 * </p> 363 * 364 * @param groupId the group ID 365 * @param start the lower bound of the range of journal folders 366 * @param end the upper bound of the range of journal folders (not inclusive) 367 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 368 * @return the ordered range of matching journal folders 369 */ 370 public java.util.List<JournalFolder> findByGroupId(long groupId, int start, 371 int end, 372 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator); 373 374 /** 375 * Returns the first journal folder in the ordered set where groupId = ?. 376 * 377 * @param groupId the group ID 378 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 379 * @return the first matching journal folder 380 * @throws NoSuchFolderException if a matching journal folder could not be found 381 */ 382 public JournalFolder findByGroupId_First(long groupId, 383 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator) 384 throws com.liferay.portlet.journal.NoSuchFolderException; 385 386 /** 387 * Returns the first journal folder in the ordered set where groupId = ?. 388 * 389 * @param groupId the group ID 390 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 391 * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found 392 */ 393 public JournalFolder fetchByGroupId_First(long groupId, 394 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator); 395 396 /** 397 * Returns the last journal folder in the ordered set where groupId = ?. 398 * 399 * @param groupId the group ID 400 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 401 * @return the last matching journal folder 402 * @throws NoSuchFolderException if a matching journal folder could not be found 403 */ 404 public JournalFolder findByGroupId_Last(long groupId, 405 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator) 406 throws com.liferay.portlet.journal.NoSuchFolderException; 407 408 /** 409 * Returns the last journal folder in the ordered set where groupId = ?. 410 * 411 * @param groupId the group ID 412 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 413 * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found 414 */ 415 public JournalFolder fetchByGroupId_Last(long groupId, 416 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator); 417 418 /** 419 * Returns the journal folders before and after the current journal folder in the ordered set where groupId = ?. 420 * 421 * @param folderId the primary key of the current journal folder 422 * @param groupId the group ID 423 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 424 * @return the previous, current, and next journal folder 425 * @throws NoSuchFolderException if a journal folder with the primary key could not be found 426 */ 427 public JournalFolder[] findByGroupId_PrevAndNext(long folderId, 428 long groupId, 429 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator) 430 throws com.liferay.portlet.journal.NoSuchFolderException; 431 432 /** 433 * Returns all the journal folders that the user has permission to view where groupId = ?. 434 * 435 * @param groupId the group ID 436 * @return the matching journal folders that the user has permission to view 437 */ 438 public java.util.List<JournalFolder> filterFindByGroupId(long groupId); 439 440 /** 441 * Returns a range of all the journal folders that the user has permission to view where groupId = ?. 442 * 443 * <p> 444 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 445 * </p> 446 * 447 * @param groupId the group ID 448 * @param start the lower bound of the range of journal folders 449 * @param end the upper bound of the range of journal folders (not inclusive) 450 * @return the range of matching journal folders that the user has permission to view 451 */ 452 public java.util.List<JournalFolder> filterFindByGroupId(long groupId, 453 int start, int end); 454 455 /** 456 * Returns an ordered range of all the journal folders that the user has permissions to view where groupId = ?. 457 * 458 * <p> 459 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 460 * </p> 461 * 462 * @param groupId the group ID 463 * @param start the lower bound of the range of journal folders 464 * @param end the upper bound of the range of journal folders (not inclusive) 465 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 466 * @return the ordered range of matching journal folders that the user has permission to view 467 */ 468 public java.util.List<JournalFolder> filterFindByGroupId(long groupId, 469 int start, int end, 470 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator); 471 472 /** 473 * Returns the journal folders before and after the current journal folder in the ordered set of journal folders that the user has permission to view where groupId = ?. 474 * 475 * @param folderId the primary key of the current journal folder 476 * @param groupId the group ID 477 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 478 * @return the previous, current, and next journal folder 479 * @throws NoSuchFolderException if a journal folder with the primary key could not be found 480 */ 481 public JournalFolder[] filterFindByGroupId_PrevAndNext(long folderId, 482 long groupId, 483 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator) 484 throws com.liferay.portlet.journal.NoSuchFolderException; 485 486 /** 487 * Removes all the journal folders where groupId = ? from the database. 488 * 489 * @param groupId the group ID 490 */ 491 public void removeByGroupId(long groupId); 492 493 /** 494 * Returns the number of journal folders where groupId = ?. 495 * 496 * @param groupId the group ID 497 * @return the number of matching journal folders 498 */ 499 public int countByGroupId(long groupId); 500 501 /** 502 * Returns the number of journal folders that the user has permission to view where groupId = ?. 503 * 504 * @param groupId the group ID 505 * @return the number of matching journal folders that the user has permission to view 506 */ 507 public int filterCountByGroupId(long groupId); 508 509 /** 510 * Returns all the journal folders where companyId = ?. 511 * 512 * @param companyId the company ID 513 * @return the matching journal folders 514 */ 515 public java.util.List<JournalFolder> findByCompanyId(long companyId); 516 517 /** 518 * Returns a range of all the journal folders where companyId = ?. 519 * 520 * <p> 521 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 522 * </p> 523 * 524 * @param companyId the company ID 525 * @param start the lower bound of the range of journal folders 526 * @param end the upper bound of the range of journal folders (not inclusive) 527 * @return the range of matching journal folders 528 */ 529 public java.util.List<JournalFolder> findByCompanyId(long companyId, 530 int start, int end); 531 532 /** 533 * Returns an ordered range of all the journal folders where companyId = ?. 534 * 535 * <p> 536 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 537 * </p> 538 * 539 * @param companyId the company ID 540 * @param start the lower bound of the range of journal folders 541 * @param end the upper bound of the range of journal folders (not inclusive) 542 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 543 * @return the ordered range of matching journal folders 544 */ 545 public java.util.List<JournalFolder> findByCompanyId(long companyId, 546 int start, int end, 547 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator); 548 549 /** 550 * Returns the first journal folder in the ordered set where companyId = ?. 551 * 552 * @param companyId the company ID 553 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 554 * @return the first matching journal folder 555 * @throws NoSuchFolderException if a matching journal folder could not be found 556 */ 557 public JournalFolder findByCompanyId_First(long companyId, 558 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator) 559 throws com.liferay.portlet.journal.NoSuchFolderException; 560 561 /** 562 * Returns the first journal folder in the ordered set where companyId = ?. 563 * 564 * @param companyId the company ID 565 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 566 * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found 567 */ 568 public JournalFolder fetchByCompanyId_First(long companyId, 569 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator); 570 571 /** 572 * Returns the last journal folder in the ordered set where companyId = ?. 573 * 574 * @param companyId the company ID 575 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 576 * @return the last matching journal folder 577 * @throws NoSuchFolderException if a matching journal folder could not be found 578 */ 579 public JournalFolder findByCompanyId_Last(long companyId, 580 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator) 581 throws com.liferay.portlet.journal.NoSuchFolderException; 582 583 /** 584 * Returns the last journal folder in the ordered set where companyId = ?. 585 * 586 * @param companyId the company ID 587 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 588 * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found 589 */ 590 public JournalFolder fetchByCompanyId_Last(long companyId, 591 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator); 592 593 /** 594 * Returns the journal folders before and after the current journal folder in the ordered set where companyId = ?. 595 * 596 * @param folderId the primary key of the current journal folder 597 * @param companyId the company ID 598 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 599 * @return the previous, current, and next journal folder 600 * @throws NoSuchFolderException if a journal folder with the primary key could not be found 601 */ 602 public JournalFolder[] findByCompanyId_PrevAndNext(long folderId, 603 long companyId, 604 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator) 605 throws com.liferay.portlet.journal.NoSuchFolderException; 606 607 /** 608 * Removes all the journal folders where companyId = ? from the database. 609 * 610 * @param companyId the company ID 611 */ 612 public void removeByCompanyId(long companyId); 613 614 /** 615 * Returns the number of journal folders where companyId = ?. 616 * 617 * @param companyId the company ID 618 * @return the number of matching journal folders 619 */ 620 public int countByCompanyId(long companyId); 621 622 /** 623 * Returns all the journal folders where groupId = ? and parentFolderId = ?. 624 * 625 * @param groupId the group ID 626 * @param parentFolderId the parent folder ID 627 * @return the matching journal folders 628 */ 629 public java.util.List<JournalFolder> findByG_P(long groupId, 630 long parentFolderId); 631 632 /** 633 * Returns a range of all the journal folders where groupId = ? and parentFolderId = ?. 634 * 635 * <p> 636 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 637 * </p> 638 * 639 * @param groupId the group ID 640 * @param parentFolderId the parent folder ID 641 * @param start the lower bound of the range of journal folders 642 * @param end the upper bound of the range of journal folders (not inclusive) 643 * @return the range of matching journal folders 644 */ 645 public java.util.List<JournalFolder> findByG_P(long groupId, 646 long parentFolderId, int start, int end); 647 648 /** 649 * Returns an ordered range of all the journal folders where groupId = ? and parentFolderId = ?. 650 * 651 * <p> 652 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 653 * </p> 654 * 655 * @param groupId the group ID 656 * @param parentFolderId the parent folder ID 657 * @param start the lower bound of the range of journal folders 658 * @param end the upper bound of the range of journal folders (not inclusive) 659 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 660 * @return the ordered range of matching journal folders 661 */ 662 public java.util.List<JournalFolder> findByG_P(long groupId, 663 long parentFolderId, int start, int end, 664 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator); 665 666 /** 667 * Returns the first journal folder in the ordered set where groupId = ? and parentFolderId = ?. 668 * 669 * @param groupId the group ID 670 * @param parentFolderId the parent folder ID 671 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 672 * @return the first matching journal folder 673 * @throws NoSuchFolderException if a matching journal folder could not be found 674 */ 675 public JournalFolder findByG_P_First(long groupId, long parentFolderId, 676 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator) 677 throws com.liferay.portlet.journal.NoSuchFolderException; 678 679 /** 680 * Returns the first journal folder in the ordered set where groupId = ? and parentFolderId = ?. 681 * 682 * @param groupId the group ID 683 * @param parentFolderId the parent folder ID 684 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 685 * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found 686 */ 687 public JournalFolder fetchByG_P_First(long groupId, long parentFolderId, 688 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator); 689 690 /** 691 * Returns the last journal folder in the ordered set where groupId = ? and parentFolderId = ?. 692 * 693 * @param groupId the group ID 694 * @param parentFolderId the parent folder ID 695 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 696 * @return the last matching journal folder 697 * @throws NoSuchFolderException if a matching journal folder could not be found 698 */ 699 public JournalFolder findByG_P_Last(long groupId, long parentFolderId, 700 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator) 701 throws com.liferay.portlet.journal.NoSuchFolderException; 702 703 /** 704 * Returns the last journal folder in the ordered set where groupId = ? and parentFolderId = ?. 705 * 706 * @param groupId the group ID 707 * @param parentFolderId the parent folder ID 708 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 709 * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found 710 */ 711 public JournalFolder fetchByG_P_Last(long groupId, long parentFolderId, 712 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator); 713 714 /** 715 * Returns the journal folders before and after the current journal folder in the ordered set where groupId = ? and parentFolderId = ?. 716 * 717 * @param folderId the primary key of the current journal folder 718 * @param groupId the group ID 719 * @param parentFolderId the parent folder ID 720 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 721 * @return the previous, current, and next journal folder 722 * @throws NoSuchFolderException if a journal folder with the primary key could not be found 723 */ 724 public JournalFolder[] findByG_P_PrevAndNext(long folderId, long groupId, 725 long parentFolderId, 726 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator) 727 throws com.liferay.portlet.journal.NoSuchFolderException; 728 729 /** 730 * Returns all the journal folders that the user has permission to view where groupId = ? and parentFolderId = ?. 731 * 732 * @param groupId the group ID 733 * @param parentFolderId the parent folder ID 734 * @return the matching journal folders that the user has permission to view 735 */ 736 public java.util.List<JournalFolder> filterFindByG_P(long groupId, 737 long parentFolderId); 738 739 /** 740 * Returns a range of all the journal folders that the user has permission to view where groupId = ? and parentFolderId = ?. 741 * 742 * <p> 743 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 744 * </p> 745 * 746 * @param groupId the group ID 747 * @param parentFolderId the parent folder ID 748 * @param start the lower bound of the range of journal folders 749 * @param end the upper bound of the range of journal folders (not inclusive) 750 * @return the range of matching journal folders that the user has permission to view 751 */ 752 public java.util.List<JournalFolder> filterFindByG_P(long groupId, 753 long parentFolderId, int start, int end); 754 755 /** 756 * Returns an ordered range of all the journal folders that the user has permissions to view where groupId = ? and parentFolderId = ?. 757 * 758 * <p> 759 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 760 * </p> 761 * 762 * @param groupId the group ID 763 * @param parentFolderId the parent folder ID 764 * @param start the lower bound of the range of journal folders 765 * @param end the upper bound of the range of journal folders (not inclusive) 766 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 767 * @return the ordered range of matching journal folders that the user has permission to view 768 */ 769 public java.util.List<JournalFolder> filterFindByG_P(long groupId, 770 long parentFolderId, int start, int end, 771 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator); 772 773 /** 774 * Returns the journal folders before and after the current journal folder in the ordered set of journal folders that the user has permission to view where groupId = ? and parentFolderId = ?. 775 * 776 * @param folderId the primary key of the current journal folder 777 * @param groupId the group ID 778 * @param parentFolderId the parent folder ID 779 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 780 * @return the previous, current, and next journal folder 781 * @throws NoSuchFolderException if a journal folder with the primary key could not be found 782 */ 783 public JournalFolder[] filterFindByG_P_PrevAndNext(long folderId, 784 long groupId, long parentFolderId, 785 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator) 786 throws com.liferay.portlet.journal.NoSuchFolderException; 787 788 /** 789 * Removes all the journal folders where groupId = ? and parentFolderId = ? from the database. 790 * 791 * @param groupId the group ID 792 * @param parentFolderId the parent folder ID 793 */ 794 public void removeByG_P(long groupId, long parentFolderId); 795 796 /** 797 * Returns the number of journal folders where groupId = ? and parentFolderId = ?. 798 * 799 * @param groupId the group ID 800 * @param parentFolderId the parent folder ID 801 * @return the number of matching journal folders 802 */ 803 public int countByG_P(long groupId, long parentFolderId); 804 805 /** 806 * Returns the number of journal folders that the user has permission to view where groupId = ? and parentFolderId = ?. 807 * 808 * @param groupId the group ID 809 * @param parentFolderId the parent folder ID 810 * @return the number of matching journal folders that the user has permission to view 811 */ 812 public int filterCountByG_P(long groupId, long parentFolderId); 813 814 /** 815 * Returns the journal folder where groupId = ? and name = ? or throws a {@link NoSuchFolderException} if it could not be found. 816 * 817 * @param groupId the group ID 818 * @param name the name 819 * @return the matching journal folder 820 * @throws NoSuchFolderException if a matching journal folder could not be found 821 */ 822 public JournalFolder findByG_N(long groupId, java.lang.String name) 823 throws com.liferay.portlet.journal.NoSuchFolderException; 824 825 /** 826 * Returns the journal folder where groupId = ? and name = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 827 * 828 * @param groupId the group ID 829 * @param name the name 830 * @return the matching journal folder, or <code>null</code> if a matching journal folder could not be found 831 */ 832 public JournalFolder fetchByG_N(long groupId, java.lang.String name); 833 834 /** 835 * Returns the journal folder where groupId = ? and name = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 836 * 837 * @param groupId the group ID 838 * @param name the name 839 * @param retrieveFromCache whether to use the finder cache 840 * @return the matching journal folder, or <code>null</code> if a matching journal folder could not be found 841 */ 842 public JournalFolder fetchByG_N(long groupId, java.lang.String name, 843 boolean retrieveFromCache); 844 845 /** 846 * Removes the journal folder where groupId = ? and name = ? from the database. 847 * 848 * @param groupId the group ID 849 * @param name the name 850 * @return the journal folder that was removed 851 */ 852 public JournalFolder removeByG_N(long groupId, java.lang.String name) 853 throws com.liferay.portlet.journal.NoSuchFolderException; 854 855 /** 856 * Returns the number of journal folders where groupId = ? and name = ?. 857 * 858 * @param groupId the group ID 859 * @param name the name 860 * @return the number of matching journal folders 861 */ 862 public int countByG_N(long groupId, java.lang.String name); 863 864 /** 865 * Returns all the journal folders where companyId = ? and status ≠ ?. 866 * 867 * @param companyId the company ID 868 * @param status the status 869 * @return the matching journal folders 870 */ 871 public java.util.List<JournalFolder> findByC_NotS(long companyId, int status); 872 873 /** 874 * Returns a range of all the journal folders where companyId = ? 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 JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query 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 companyId the company ID 881 * @param status the status 882 * @param start the lower bound of the range of journal folders 883 * @param end the upper bound of the range of journal folders (not inclusive) 884 * @return the range of matching journal folders 885 */ 886 public java.util.List<JournalFolder> findByC_NotS(long companyId, 887 int status, int start, int end); 888 889 /** 890 * Returns an ordered range of all the journal folders where companyId = ? 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 JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query 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 companyId the company ID 897 * @param status the status 898 * @param start the lower bound of the range of journal folders 899 * @param end the upper bound of the range of journal folders (not inclusive) 900 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 901 * @return the ordered range of matching journal folders 902 */ 903 public java.util.List<JournalFolder> findByC_NotS(long companyId, 904 int status, int start, int end, 905 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator); 906 907 /** 908 * Returns the first journal folder in the ordered set where companyId = ? and status ≠ ?. 909 * 910 * @param companyId the company 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 journal folder 914 * @throws NoSuchFolderException if a matching journal folder could not be found 915 */ 916 public JournalFolder findByC_NotS_First(long companyId, int status, 917 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator) 918 throws com.liferay.portlet.journal.NoSuchFolderException; 919 920 /** 921 * Returns the first journal folder in the ordered set where companyId = ? and status ≠ ?. 922 * 923 * @param companyId the company 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 journal folder, or <code>null</code> if a matching journal folder could not be found 927 */ 928 public JournalFolder fetchByC_NotS_First(long companyId, int status, 929 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator); 930 931 /** 932 * Returns the last journal folder in the ordered set where companyId = ? and status ≠ ?. 933 * 934 * @param companyId the company 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 journal folder 938 * @throws NoSuchFolderException if a matching journal folder could not be found 939 */ 940 public JournalFolder findByC_NotS_Last(long companyId, int status, 941 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator) 942 throws com.liferay.portlet.journal.NoSuchFolderException; 943 944 /** 945 * Returns the last journal folder in the ordered set where companyId = ? and status ≠ ?. 946 * 947 * @param companyId the company 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 journal folder, or <code>null</code> if a matching journal folder could not be found 951 */ 952 public JournalFolder fetchByC_NotS_Last(long companyId, int status, 953 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator); 954 955 /** 956 * Returns the journal folders before and after the current journal folder in the ordered set where companyId = ? and status ≠ ?. 957 * 958 * @param folderId the primary key of the current journal folder 959 * @param companyId the company 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 journal folder 963 * @throws NoSuchFolderException if a journal folder with the primary key could not be found 964 */ 965 public JournalFolder[] findByC_NotS_PrevAndNext(long folderId, 966 long companyId, int status, 967 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator) 968 throws com.liferay.portlet.journal.NoSuchFolderException; 969 970 /** 971 * Removes all the journal folders where companyId = ? and status ≠ ? from the database. 972 * 973 * @param companyId the company ID 974 * @param status the status 975 */ 976 public void removeByC_NotS(long companyId, int status); 977 978 /** 979 * Returns the number of journal folders where companyId = ? and status ≠ ?. 980 * 981 * @param companyId the company ID 982 * @param status the status 983 * @return the number of matching journal folders 984 */ 985 public int countByC_NotS(long companyId, int status); 986 987 /** 988 * Returns the journal folder where groupId = ? and parentFolderId = ? and name = ? or throws a {@link NoSuchFolderException} if it could not be found. 989 * 990 * @param groupId the group ID 991 * @param parentFolderId the parent folder ID 992 * @param name the name 993 * @return the matching journal folder 994 * @throws NoSuchFolderException if a matching journal folder could not be found 995 */ 996 public JournalFolder findByG_P_N(long groupId, long parentFolderId, 997 java.lang.String name) 998 throws com.liferay.portlet.journal.NoSuchFolderException; 999 1000 /** 1001 * Returns the journal folder where groupId = ? and parentFolderId = ? and name = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 1002 * 1003 * @param groupId the group ID 1004 * @param parentFolderId the parent folder ID 1005 * @param name the name 1006 * @return the matching journal folder, or <code>null</code> if a matching journal folder could not be found 1007 */ 1008 public JournalFolder fetchByG_P_N(long groupId, long parentFolderId, 1009 java.lang.String name); 1010 1011 /** 1012 * Returns the journal folder where groupId = ? and parentFolderId = ? and name = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 1013 * 1014 * @param groupId the group ID 1015 * @param parentFolderId the parent folder ID 1016 * @param name the name 1017 * @param retrieveFromCache whether to use the finder cache 1018 * @return the matching journal folder, or <code>null</code> if a matching journal folder could not be found 1019 */ 1020 public JournalFolder fetchByG_P_N(long groupId, long parentFolderId, 1021 java.lang.String name, boolean retrieveFromCache); 1022 1023 /** 1024 * Removes the journal folder where groupId = ? and parentFolderId = ? and name = ? from the database. 1025 * 1026 * @param groupId the group ID 1027 * @param parentFolderId the parent folder ID 1028 * @param name the name 1029 * @return the journal folder that was removed 1030 */ 1031 public JournalFolder removeByG_P_N(long groupId, long parentFolderId, 1032 java.lang.String name) 1033 throws com.liferay.portlet.journal.NoSuchFolderException; 1034 1035 /** 1036 * Returns the number of journal folders where groupId = ? and parentFolderId = ? and name = ?. 1037 * 1038 * @param groupId the group ID 1039 * @param parentFolderId the parent folder ID 1040 * @param name the name 1041 * @return the number of matching journal folders 1042 */ 1043 public int countByG_P_N(long groupId, long parentFolderId, 1044 java.lang.String name); 1045 1046 /** 1047 * Returns all the journal folders where groupId = ? and parentFolderId = ? and status = ?. 1048 * 1049 * @param groupId the group ID 1050 * @param parentFolderId the parent folder ID 1051 * @param status the status 1052 * @return the matching journal folders 1053 */ 1054 public java.util.List<JournalFolder> findByG_P_S(long groupId, 1055 long parentFolderId, int status); 1056 1057 /** 1058 * Returns a range of all the journal folders where groupId = ? and parentFolderId = ? and status = ?. 1059 * 1060 * <p> 1061 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1062 * </p> 1063 * 1064 * @param groupId the group ID 1065 * @param parentFolderId the parent folder ID 1066 * @param status the status 1067 * @param start the lower bound of the range of journal folders 1068 * @param end the upper bound of the range of journal folders (not inclusive) 1069 * @return the range of matching journal folders 1070 */ 1071 public java.util.List<JournalFolder> findByG_P_S(long groupId, 1072 long parentFolderId, int status, int start, int end); 1073 1074 /** 1075 * Returns an ordered range of all the journal folders where groupId = ? and parentFolderId = ? and status = ?. 1076 * 1077 * <p> 1078 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1079 * </p> 1080 * 1081 * @param groupId the group ID 1082 * @param parentFolderId the parent folder ID 1083 * @param status the status 1084 * @param start the lower bound of the range of journal folders 1085 * @param end the upper bound of the range of journal folders (not inclusive) 1086 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1087 * @return the ordered range of matching journal folders 1088 */ 1089 public java.util.List<JournalFolder> findByG_P_S(long groupId, 1090 long parentFolderId, int status, int start, int end, 1091 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator); 1092 1093 /** 1094 * Returns the first journal folder in the ordered set where groupId = ? and parentFolderId = ? and status = ?. 1095 * 1096 * @param groupId the group ID 1097 * @param parentFolderId the parent folder ID 1098 * @param status the status 1099 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1100 * @return the first matching journal folder 1101 * @throws NoSuchFolderException if a matching journal folder could not be found 1102 */ 1103 public JournalFolder findByG_P_S_First(long groupId, long parentFolderId, 1104 int status, 1105 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator) 1106 throws com.liferay.portlet.journal.NoSuchFolderException; 1107 1108 /** 1109 * Returns the first journal folder in the ordered set where groupId = ? and parentFolderId = ? and status = ?. 1110 * 1111 * @param groupId the group ID 1112 * @param parentFolderId the parent folder ID 1113 * @param status the status 1114 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1115 * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found 1116 */ 1117 public JournalFolder fetchByG_P_S_First(long groupId, long parentFolderId, 1118 int status, 1119 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator); 1120 1121 /** 1122 * Returns the last journal folder in the ordered set where groupId = ? and parentFolderId = ? and status = ?. 1123 * 1124 * @param groupId the group ID 1125 * @param parentFolderId the parent folder ID 1126 * @param status the status 1127 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1128 * @return the last matching journal folder 1129 * @throws NoSuchFolderException if a matching journal folder could not be found 1130 */ 1131 public JournalFolder findByG_P_S_Last(long groupId, long parentFolderId, 1132 int status, 1133 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator) 1134 throws com.liferay.portlet.journal.NoSuchFolderException; 1135 1136 /** 1137 * Returns the last journal folder in the ordered set where groupId = ? and parentFolderId = ? and status = ?. 1138 * 1139 * @param groupId the group ID 1140 * @param parentFolderId the parent folder ID 1141 * @param status the status 1142 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1143 * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found 1144 */ 1145 public JournalFolder fetchByG_P_S_Last(long groupId, long parentFolderId, 1146 int status, 1147 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator); 1148 1149 /** 1150 * Returns the journal folders before and after the current journal folder in the ordered set where groupId = ? and parentFolderId = ? and status = ?. 1151 * 1152 * @param folderId the primary key of the current journal folder 1153 * @param groupId the group ID 1154 * @param parentFolderId the parent folder ID 1155 * @param status the status 1156 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1157 * @return the previous, current, and next journal folder 1158 * @throws NoSuchFolderException if a journal folder with the primary key could not be found 1159 */ 1160 public JournalFolder[] findByG_P_S_PrevAndNext(long folderId, long groupId, 1161 long parentFolderId, int status, 1162 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator) 1163 throws com.liferay.portlet.journal.NoSuchFolderException; 1164 1165 /** 1166 * Returns all the journal folders that the user has permission to view where groupId = ? and parentFolderId = ? and status = ?. 1167 * 1168 * @param groupId the group ID 1169 * @param parentFolderId the parent folder ID 1170 * @param status the status 1171 * @return the matching journal folders that the user has permission to view 1172 */ 1173 public java.util.List<JournalFolder> filterFindByG_P_S(long groupId, 1174 long parentFolderId, int status); 1175 1176 /** 1177 * Returns a range of all the journal folders that the user has permission to view where groupId = ? and parentFolderId = ? and status = ?. 1178 * 1179 * <p> 1180 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1181 * </p> 1182 * 1183 * @param groupId the group ID 1184 * @param parentFolderId the parent folder ID 1185 * @param status the status 1186 * @param start the lower bound of the range of journal folders 1187 * @param end the upper bound of the range of journal folders (not inclusive) 1188 * @return the range of matching journal folders that the user has permission to view 1189 */ 1190 public java.util.List<JournalFolder> filterFindByG_P_S(long groupId, 1191 long parentFolderId, int status, int start, int end); 1192 1193 /** 1194 * Returns an ordered range of all the journal folders that the user has permissions to view where groupId = ? and parentFolderId = ? and status = ?. 1195 * 1196 * <p> 1197 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1198 * </p> 1199 * 1200 * @param groupId the group ID 1201 * @param parentFolderId the parent folder ID 1202 * @param status the status 1203 * @param start the lower bound of the range of journal folders 1204 * @param end the upper bound of the range of journal folders (not inclusive) 1205 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1206 * @return the ordered range of matching journal folders that the user has permission to view 1207 */ 1208 public java.util.List<JournalFolder> filterFindByG_P_S(long groupId, 1209 long parentFolderId, int status, int start, int end, 1210 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator); 1211 1212 /** 1213 * Returns the journal folders before and after the current journal folder in the ordered set of journal folders that the user has permission to view where groupId = ? and parentFolderId = ? and status = ?. 1214 * 1215 * @param folderId the primary key of the current journal folder 1216 * @param groupId the group ID 1217 * @param parentFolderId the parent folder ID 1218 * @param status the status 1219 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1220 * @return the previous, current, and next journal folder 1221 * @throws NoSuchFolderException if a journal folder with the primary key could not be found 1222 */ 1223 public JournalFolder[] filterFindByG_P_S_PrevAndNext(long folderId, 1224 long groupId, long parentFolderId, int status, 1225 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator) 1226 throws com.liferay.portlet.journal.NoSuchFolderException; 1227 1228 /** 1229 * Removes all the journal folders where groupId = ? and parentFolderId = ? and status = ? from the database. 1230 * 1231 * @param groupId the group ID 1232 * @param parentFolderId the parent folder ID 1233 * @param status the status 1234 */ 1235 public void removeByG_P_S(long groupId, long parentFolderId, int status); 1236 1237 /** 1238 * Returns the number of journal folders where groupId = ? and parentFolderId = ? and status = ?. 1239 * 1240 * @param groupId the group ID 1241 * @param parentFolderId the parent folder ID 1242 * @param status the status 1243 * @return the number of matching journal folders 1244 */ 1245 public int countByG_P_S(long groupId, long parentFolderId, int status); 1246 1247 /** 1248 * Returns the number of journal folders that the user has permission to view where groupId = ? and parentFolderId = ? and status = ?. 1249 * 1250 * @param groupId the group ID 1251 * @param parentFolderId the parent folder ID 1252 * @param status the status 1253 * @return the number of matching journal folders that the user has permission to view 1254 */ 1255 public int filterCountByG_P_S(long groupId, long parentFolderId, int status); 1256 1257 /** 1258 * Returns all the journal folders where groupId = ? and parentFolderId = ? and status ≠ ?. 1259 * 1260 * @param groupId the group ID 1261 * @param parentFolderId the parent folder ID 1262 * @param status the status 1263 * @return the matching journal folders 1264 */ 1265 public java.util.List<JournalFolder> findByG_P_NotS(long groupId, 1266 long parentFolderId, int status); 1267 1268 /** 1269 * Returns a range of all the journal folders where groupId = ? and parentFolderId = ? and status ≠ ?. 1270 * 1271 * <p> 1272 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1273 * </p> 1274 * 1275 * @param groupId the group ID 1276 * @param parentFolderId the parent folder ID 1277 * @param status the status 1278 * @param start the lower bound of the range of journal folders 1279 * @param end the upper bound of the range of journal folders (not inclusive) 1280 * @return the range of matching journal folders 1281 */ 1282 public java.util.List<JournalFolder> findByG_P_NotS(long groupId, 1283 long parentFolderId, int status, int start, int end); 1284 1285 /** 1286 * Returns an ordered range of all the journal folders where groupId = ? and parentFolderId = ? and status ≠ ?. 1287 * 1288 * <p> 1289 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1290 * </p> 1291 * 1292 * @param groupId the group ID 1293 * @param parentFolderId the parent folder ID 1294 * @param status the status 1295 * @param start the lower bound of the range of journal folders 1296 * @param end the upper bound of the range of journal folders (not inclusive) 1297 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1298 * @return the ordered range of matching journal folders 1299 */ 1300 public java.util.List<JournalFolder> findByG_P_NotS(long groupId, 1301 long parentFolderId, int status, int start, int end, 1302 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator); 1303 1304 /** 1305 * Returns the first journal folder in the ordered set where groupId = ? and parentFolderId = ? and status ≠ ?. 1306 * 1307 * @param groupId the group ID 1308 * @param parentFolderId the parent folder ID 1309 * @param status the status 1310 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1311 * @return the first matching journal folder 1312 * @throws NoSuchFolderException if a matching journal folder could not be found 1313 */ 1314 public JournalFolder findByG_P_NotS_First(long groupId, 1315 long parentFolderId, int status, 1316 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator) 1317 throws com.liferay.portlet.journal.NoSuchFolderException; 1318 1319 /** 1320 * Returns the first journal folder in the ordered set where groupId = ? and parentFolderId = ? and status ≠ ?. 1321 * 1322 * @param groupId the group ID 1323 * @param parentFolderId the parent folder ID 1324 * @param status the status 1325 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1326 * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found 1327 */ 1328 public JournalFolder fetchByG_P_NotS_First(long groupId, 1329 long parentFolderId, int status, 1330 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator); 1331 1332 /** 1333 * Returns the last journal folder in the ordered set where groupId = ? and parentFolderId = ? and status ≠ ?. 1334 * 1335 * @param groupId the group ID 1336 * @param parentFolderId the parent folder ID 1337 * @param status the status 1338 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1339 * @return the last matching journal folder 1340 * @throws NoSuchFolderException if a matching journal folder could not be found 1341 */ 1342 public JournalFolder findByG_P_NotS_Last(long groupId, long parentFolderId, 1343 int status, 1344 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator) 1345 throws com.liferay.portlet.journal.NoSuchFolderException; 1346 1347 /** 1348 * Returns the last journal folder in the ordered set where groupId = ? and parentFolderId = ? and status ≠ ?. 1349 * 1350 * @param groupId the group ID 1351 * @param parentFolderId the parent folder ID 1352 * @param status the status 1353 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1354 * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found 1355 */ 1356 public JournalFolder fetchByG_P_NotS_Last(long groupId, 1357 long parentFolderId, int status, 1358 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator); 1359 1360 /** 1361 * Returns the journal folders before and after the current journal folder in the ordered set where groupId = ? and parentFolderId = ? and status ≠ ?. 1362 * 1363 * @param folderId the primary key of the current journal folder 1364 * @param groupId the group ID 1365 * @param parentFolderId the parent folder ID 1366 * @param status the status 1367 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1368 * @return the previous, current, and next journal folder 1369 * @throws NoSuchFolderException if a journal folder with the primary key could not be found 1370 */ 1371 public JournalFolder[] findByG_P_NotS_PrevAndNext(long folderId, 1372 long groupId, long parentFolderId, int status, 1373 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator) 1374 throws com.liferay.portlet.journal.NoSuchFolderException; 1375 1376 /** 1377 * Returns all the journal folders that the user has permission to view where groupId = ? and parentFolderId = ? and status ≠ ?. 1378 * 1379 * @param groupId the group ID 1380 * @param parentFolderId the parent folder ID 1381 * @param status the status 1382 * @return the matching journal folders that the user has permission to view 1383 */ 1384 public java.util.List<JournalFolder> filterFindByG_P_NotS(long groupId, 1385 long parentFolderId, int status); 1386 1387 /** 1388 * Returns a range of all the journal folders that the user has permission to view where groupId = ? and parentFolderId = ? and status ≠ ?. 1389 * 1390 * <p> 1391 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1392 * </p> 1393 * 1394 * @param groupId the group ID 1395 * @param parentFolderId the parent folder ID 1396 * @param status the status 1397 * @param start the lower bound of the range of journal folders 1398 * @param end the upper bound of the range of journal folders (not inclusive) 1399 * @return the range of matching journal folders that the user has permission to view 1400 */ 1401 public java.util.List<JournalFolder> filterFindByG_P_NotS(long groupId, 1402 long parentFolderId, int status, int start, int end); 1403 1404 /** 1405 * Returns an ordered range of all the journal folders that the user has permissions to view where groupId = ? and parentFolderId = ? and status ≠ ?. 1406 * 1407 * <p> 1408 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1409 * </p> 1410 * 1411 * @param groupId the group ID 1412 * @param parentFolderId the parent folder ID 1413 * @param status the status 1414 * @param start the lower bound of the range of journal folders 1415 * @param end the upper bound of the range of journal folders (not inclusive) 1416 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1417 * @return the ordered range of matching journal folders that the user has permission to view 1418 */ 1419 public java.util.List<JournalFolder> filterFindByG_P_NotS(long groupId, 1420 long parentFolderId, int status, int start, int end, 1421 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator); 1422 1423 /** 1424 * Returns the journal folders before and after the current journal folder in the ordered set of journal folders that the user has permission to view where groupId = ? and parentFolderId = ? and status ≠ ?. 1425 * 1426 * @param folderId the primary key of the current journal folder 1427 * @param groupId the group ID 1428 * @param parentFolderId the parent folder ID 1429 * @param status the status 1430 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1431 * @return the previous, current, and next journal folder 1432 * @throws NoSuchFolderException if a journal folder with the primary key could not be found 1433 */ 1434 public JournalFolder[] filterFindByG_P_NotS_PrevAndNext(long folderId, 1435 long groupId, long parentFolderId, int status, 1436 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator) 1437 throws com.liferay.portlet.journal.NoSuchFolderException; 1438 1439 /** 1440 * Removes all the journal folders where groupId = ? and parentFolderId = ? and status ≠ ? from the database. 1441 * 1442 * @param groupId the group ID 1443 * @param parentFolderId the parent folder ID 1444 * @param status the status 1445 */ 1446 public void removeByG_P_NotS(long groupId, long parentFolderId, int status); 1447 1448 /** 1449 * Returns the number of journal folders where groupId = ? and parentFolderId = ? and status ≠ ?. 1450 * 1451 * @param groupId the group ID 1452 * @param parentFolderId the parent folder ID 1453 * @param status the status 1454 * @return the number of matching journal folders 1455 */ 1456 public int countByG_P_NotS(long groupId, long parentFolderId, int status); 1457 1458 /** 1459 * Returns the number of journal folders that the user has permission to view where groupId = ? and parentFolderId = ? and status ≠ ?. 1460 * 1461 * @param groupId the group ID 1462 * @param parentFolderId the parent folder ID 1463 * @param status the status 1464 * @return the number of matching journal folders that the user has permission to view 1465 */ 1466 public int filterCountByG_P_NotS(long groupId, long parentFolderId, 1467 int status); 1468 1469 /** 1470 * Returns all the journal folders where folderId > ? and companyId = ? and parentFolderId = ? and status ≠ ?. 1471 * 1472 * @param folderId the folder ID 1473 * @param companyId the company ID 1474 * @param parentFolderId the parent folder ID 1475 * @param status the status 1476 * @return the matching journal folders 1477 */ 1478 public java.util.List<JournalFolder> findByF_C_P_NotS(long folderId, 1479 long companyId, long parentFolderId, int status); 1480 1481 /** 1482 * Returns a range of all the journal folders where folderId > ? and companyId = ? and parentFolderId = ? and status ≠ ?. 1483 * 1484 * <p> 1485 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1486 * </p> 1487 * 1488 * @param folderId the folder ID 1489 * @param companyId the company ID 1490 * @param parentFolderId the parent folder ID 1491 * @param status the status 1492 * @param start the lower bound of the range of journal folders 1493 * @param end the upper bound of the range of journal folders (not inclusive) 1494 * @return the range of matching journal folders 1495 */ 1496 public java.util.List<JournalFolder> findByF_C_P_NotS(long folderId, 1497 long companyId, long parentFolderId, int status, int start, int end); 1498 1499 /** 1500 * Returns an ordered range of all the journal folders where folderId > ? and companyId = ? and parentFolderId = ? and status ≠ ?. 1501 * 1502 * <p> 1503 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1504 * </p> 1505 * 1506 * @param folderId the folder ID 1507 * @param companyId the company ID 1508 * @param parentFolderId the parent folder ID 1509 * @param status the status 1510 * @param start the lower bound of the range of journal folders 1511 * @param end the upper bound of the range of journal folders (not inclusive) 1512 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1513 * @return the ordered range of matching journal folders 1514 */ 1515 public java.util.List<JournalFolder> findByF_C_P_NotS(long folderId, 1516 long companyId, long parentFolderId, int status, int start, int end, 1517 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator); 1518 1519 /** 1520 * Returns the first journal folder in the ordered set where folderId > ? and companyId = ? and parentFolderId = ? and status ≠ ?. 1521 * 1522 * @param folderId the folder ID 1523 * @param companyId the company ID 1524 * @param parentFolderId the parent folder ID 1525 * @param status the status 1526 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1527 * @return the first matching journal folder 1528 * @throws NoSuchFolderException if a matching journal folder could not be found 1529 */ 1530 public JournalFolder findByF_C_P_NotS_First(long folderId, long companyId, 1531 long parentFolderId, int status, 1532 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator) 1533 throws com.liferay.portlet.journal.NoSuchFolderException; 1534 1535 /** 1536 * Returns the first journal folder in the ordered set where folderId > ? and companyId = ? and parentFolderId = ? and status ≠ ?. 1537 * 1538 * @param folderId the folder ID 1539 * @param companyId the company ID 1540 * @param parentFolderId the parent folder ID 1541 * @param status the status 1542 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1543 * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found 1544 */ 1545 public JournalFolder fetchByF_C_P_NotS_First(long folderId, long companyId, 1546 long parentFolderId, int status, 1547 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator); 1548 1549 /** 1550 * Returns the last journal folder in the ordered set where folderId > ? and companyId = ? and parentFolderId = ? and status ≠ ?. 1551 * 1552 * @param folderId the folder ID 1553 * @param companyId the company ID 1554 * @param parentFolderId the parent folder ID 1555 * @param status the status 1556 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1557 * @return the last matching journal folder 1558 * @throws NoSuchFolderException if a matching journal folder could not be found 1559 */ 1560 public JournalFolder findByF_C_P_NotS_Last(long folderId, long companyId, 1561 long parentFolderId, int status, 1562 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator) 1563 throws com.liferay.portlet.journal.NoSuchFolderException; 1564 1565 /** 1566 * Returns the last journal folder in the ordered set where folderId > ? and companyId = ? and parentFolderId = ? and status ≠ ?. 1567 * 1568 * @param folderId the folder ID 1569 * @param companyId the company ID 1570 * @param parentFolderId the parent folder ID 1571 * @param status the status 1572 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1573 * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found 1574 */ 1575 public JournalFolder fetchByF_C_P_NotS_Last(long folderId, long companyId, 1576 long parentFolderId, int status, 1577 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator); 1578 1579 /** 1580 * Removes all the journal folders where folderId > ? and companyId = ? and parentFolderId = ? and status ≠ ? from the database. 1581 * 1582 * @param folderId the folder ID 1583 * @param companyId the company ID 1584 * @param parentFolderId the parent folder ID 1585 * @param status the status 1586 */ 1587 public void removeByF_C_P_NotS(long folderId, long companyId, 1588 long parentFolderId, int status); 1589 1590 /** 1591 * Returns the number of journal folders where folderId > ? and companyId = ? and parentFolderId = ? and status ≠ ?. 1592 * 1593 * @param folderId the folder ID 1594 * @param companyId the company ID 1595 * @param parentFolderId the parent folder ID 1596 * @param status the status 1597 * @return the number of matching journal folders 1598 */ 1599 public int countByF_C_P_NotS(long folderId, long companyId, 1600 long parentFolderId, int status); 1601 1602 /** 1603 * Caches the journal folder in the entity cache if it is enabled. 1604 * 1605 * @param journalFolder the journal folder 1606 */ 1607 public void cacheResult(JournalFolder journalFolder); 1608 1609 /** 1610 * Caches the journal folders in the entity cache if it is enabled. 1611 * 1612 * @param journalFolders the journal folders 1613 */ 1614 public void cacheResult(java.util.List<JournalFolder> journalFolders); 1615 1616 /** 1617 * Creates a new journal folder with the primary key. Does not add the journal folder to the database. 1618 * 1619 * @param folderId the primary key for the new journal folder 1620 * @return the new journal folder 1621 */ 1622 public JournalFolder create(long folderId); 1623 1624 /** 1625 * Removes the journal folder with the primary key from the database. Also notifies the appropriate model listeners. 1626 * 1627 * @param folderId the primary key of the journal folder 1628 * @return the journal folder that was removed 1629 * @throws NoSuchFolderException if a journal folder with the primary key could not be found 1630 */ 1631 public JournalFolder remove(long folderId) 1632 throws com.liferay.portlet.journal.NoSuchFolderException; 1633 1634 public JournalFolder updateImpl(JournalFolder journalFolder); 1635 1636 /** 1637 * Returns the journal folder with the primary key or throws a {@link NoSuchFolderException} if it could not be found. 1638 * 1639 * @param folderId the primary key of the journal folder 1640 * @return the journal folder 1641 * @throws NoSuchFolderException if a journal folder with the primary key could not be found 1642 */ 1643 public JournalFolder findByPrimaryKey(long folderId) 1644 throws com.liferay.portlet.journal.NoSuchFolderException; 1645 1646 /** 1647 * Returns the journal folder with the primary key or returns <code>null</code> if it could not be found. 1648 * 1649 * @param folderId the primary key of the journal folder 1650 * @return the journal folder, or <code>null</code> if a journal folder with the primary key could not be found 1651 */ 1652 public JournalFolder fetchByPrimaryKey(long folderId); 1653 1654 @Override 1655 public java.util.Map<java.io.Serializable, JournalFolder> fetchByPrimaryKeys( 1656 java.util.Set<java.io.Serializable> primaryKeys); 1657 1658 /** 1659 * Returns all the journal folders. 1660 * 1661 * @return the journal folders 1662 */ 1663 public java.util.List<JournalFolder> findAll(); 1664 1665 /** 1666 * Returns a range of all the journal folders. 1667 * 1668 * <p> 1669 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1670 * </p> 1671 * 1672 * @param start the lower bound of the range of journal folders 1673 * @param end the upper bound of the range of journal folders (not inclusive) 1674 * @return the range of journal folders 1675 */ 1676 public java.util.List<JournalFolder> findAll(int start, int end); 1677 1678 /** 1679 * Returns an ordered range of all the journal folders. 1680 * 1681 * <p> 1682 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link JournalFolderModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1683 * </p> 1684 * 1685 * @param start the lower bound of the range of journal folders 1686 * @param end the upper bound of the range of journal folders (not inclusive) 1687 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1688 * @return the ordered range of journal folders 1689 */ 1690 public java.util.List<JournalFolder> findAll(int start, int end, 1691 com.liferay.portal.kernel.util.OrderByComparator<JournalFolder> orderByComparator); 1692 1693 /** 1694 * Removes all the journal folders from the database. 1695 */ 1696 public void removeAll(); 1697 1698 /** 1699 * Returns the number of journal folders. 1700 * 1701 * @return the number of journal folders 1702 */ 1703 public int countAll(); 1704 }