001 /** 002 * Copyright (c) 2000-2013 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 com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 018 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 019 import com.liferay.portal.kernel.exception.SystemException; 020 import com.liferay.portal.kernel.util.OrderByComparator; 021 import com.liferay.portal.kernel.util.ReferenceRegistry; 022 import com.liferay.portal.service.ServiceContext; 023 024 import com.liferay.portlet.journal.model.JournalFolder; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the journal folder service. This utility wraps {@link JournalFolderPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 030 * 031 * <p> 032 * Caching information and settings can be found in <code>portal.properties</code> 033 * </p> 034 * 035 * @author Brian Wing Shun Chan 036 * @see JournalFolderPersistence 037 * @see JournalFolderPersistenceImpl 038 * @generated 039 */ 040 public class JournalFolderUtil { 041 /* 042 * NOTE FOR DEVELOPERS: 043 * 044 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 045 */ 046 047 /** 048 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 049 */ 050 public static void clearCache() { 051 getPersistence().clearCache(); 052 } 053 054 /** 055 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 056 */ 057 public static void clearCache(JournalFolder journalFolder) { 058 getPersistence().clearCache(journalFolder); 059 } 060 061 /** 062 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 063 */ 064 public long countWithDynamicQuery(DynamicQuery dynamicQuery) 065 throws SystemException { 066 return getPersistence().countWithDynamicQuery(dynamicQuery); 067 } 068 069 /** 070 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 071 */ 072 public static List<JournalFolder> findWithDynamicQuery( 073 DynamicQuery dynamicQuery) throws SystemException { 074 return getPersistence().findWithDynamicQuery(dynamicQuery); 075 } 076 077 /** 078 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 079 */ 080 public static List<JournalFolder> findWithDynamicQuery( 081 DynamicQuery dynamicQuery, int start, int end) 082 throws SystemException { 083 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 084 } 085 086 /** 087 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 088 */ 089 public static List<JournalFolder> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator orderByComparator) throws SystemException { 092 return getPersistence() 093 .findWithDynamicQuery(dynamicQuery, start, end, 094 orderByComparator); 095 } 096 097 /** 098 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 099 */ 100 public static JournalFolder update(JournalFolder journalFolder) 101 throws SystemException { 102 return getPersistence().update(journalFolder); 103 } 104 105 /** 106 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 107 */ 108 public static JournalFolder update(JournalFolder journalFolder, 109 ServiceContext serviceContext) throws SystemException { 110 return getPersistence().update(journalFolder, serviceContext); 111 } 112 113 /** 114 * Returns all the journal folders where uuid = ?. 115 * 116 * @param uuid the uuid 117 * @return the matching journal folders 118 * @throws SystemException if a system exception occurred 119 */ 120 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByUuid( 121 java.lang.String uuid) 122 throws com.liferay.portal.kernel.exception.SystemException { 123 return getPersistence().findByUuid(uuid); 124 } 125 126 /** 127 * Returns a range of all the journal folders where uuid = ?. 128 * 129 * <p> 130 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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. 131 * </p> 132 * 133 * @param uuid the uuid 134 * @param start the lower bound of the range of journal folders 135 * @param end the upper bound of the range of journal folders (not inclusive) 136 * @return the range of matching journal folders 137 * @throws SystemException if a system exception occurred 138 */ 139 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByUuid( 140 java.lang.String uuid, int start, int end) 141 throws com.liferay.portal.kernel.exception.SystemException { 142 return getPersistence().findByUuid(uuid, start, end); 143 } 144 145 /** 146 * Returns an ordered range of all the journal folders where uuid = ?. 147 * 148 * <p> 149 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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. 150 * </p> 151 * 152 * @param uuid the uuid 153 * @param start the lower bound of the range of journal folders 154 * @param end the upper bound of the range of journal folders (not inclusive) 155 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 156 * @return the ordered range of matching journal folders 157 * @throws SystemException if a system exception occurred 158 */ 159 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByUuid( 160 java.lang.String uuid, int start, int end, 161 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 162 throws com.liferay.portal.kernel.exception.SystemException { 163 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 164 } 165 166 /** 167 * Returns the first journal folder in the ordered set where uuid = ?. 168 * 169 * @param uuid the uuid 170 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 171 * @return the first matching journal folder 172 * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found 173 * @throws SystemException if a system exception occurred 174 */ 175 public static com.liferay.portlet.journal.model.JournalFolder findByUuid_First( 176 java.lang.String uuid, 177 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 178 throws com.liferay.portal.kernel.exception.SystemException, 179 com.liferay.portlet.journal.NoSuchFolderException { 180 return getPersistence().findByUuid_First(uuid, orderByComparator); 181 } 182 183 /** 184 * Returns the first journal folder in the ordered set where uuid = ?. 185 * 186 * @param uuid the uuid 187 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 188 * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found 189 * @throws SystemException if a system exception occurred 190 */ 191 public static com.liferay.portlet.journal.model.JournalFolder fetchByUuid_First( 192 java.lang.String uuid, 193 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 194 throws com.liferay.portal.kernel.exception.SystemException { 195 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 196 } 197 198 /** 199 * Returns the last journal folder in the ordered set where uuid = ?. 200 * 201 * @param uuid the uuid 202 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 203 * @return the last matching journal folder 204 * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found 205 * @throws SystemException if a system exception occurred 206 */ 207 public static com.liferay.portlet.journal.model.JournalFolder findByUuid_Last( 208 java.lang.String uuid, 209 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 210 throws com.liferay.portal.kernel.exception.SystemException, 211 com.liferay.portlet.journal.NoSuchFolderException { 212 return getPersistence().findByUuid_Last(uuid, orderByComparator); 213 } 214 215 /** 216 * Returns the last journal folder in the ordered set where uuid = ?. 217 * 218 * @param uuid the uuid 219 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 220 * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found 221 * @throws SystemException if a system exception occurred 222 */ 223 public static com.liferay.portlet.journal.model.JournalFolder fetchByUuid_Last( 224 java.lang.String uuid, 225 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 226 throws com.liferay.portal.kernel.exception.SystemException { 227 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 228 } 229 230 /** 231 * Returns the journal folders before and after the current journal folder in the ordered set where uuid = ?. 232 * 233 * @param folderId the primary key of the current journal folder 234 * @param uuid the uuid 235 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 236 * @return the previous, current, and next journal folder 237 * @throws com.liferay.portlet.journal.NoSuchFolderException if a journal folder with the primary key could not be found 238 * @throws SystemException if a system exception occurred 239 */ 240 public static com.liferay.portlet.journal.model.JournalFolder[] findByUuid_PrevAndNext( 241 long folderId, java.lang.String uuid, 242 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 243 throws com.liferay.portal.kernel.exception.SystemException, 244 com.liferay.portlet.journal.NoSuchFolderException { 245 return getPersistence() 246 .findByUuid_PrevAndNext(folderId, uuid, orderByComparator); 247 } 248 249 /** 250 * Removes all the journal folders where uuid = ? from the database. 251 * 252 * @param uuid the uuid 253 * @throws SystemException if a system exception occurred 254 */ 255 public static void removeByUuid(java.lang.String uuid) 256 throws com.liferay.portal.kernel.exception.SystemException { 257 getPersistence().removeByUuid(uuid); 258 } 259 260 /** 261 * Returns the number of journal folders where uuid = ?. 262 * 263 * @param uuid the uuid 264 * @return the number of matching journal folders 265 * @throws SystemException if a system exception occurred 266 */ 267 public static int countByUuid(java.lang.String uuid) 268 throws com.liferay.portal.kernel.exception.SystemException { 269 return getPersistence().countByUuid(uuid); 270 } 271 272 /** 273 * Returns the journal folder where uuid = ? and groupId = ? or throws a {@link com.liferay.portlet.journal.NoSuchFolderException} if it could not be found. 274 * 275 * @param uuid the uuid 276 * @param groupId the group ID 277 * @return the matching journal folder 278 * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found 279 * @throws SystemException if a system exception occurred 280 */ 281 public static com.liferay.portlet.journal.model.JournalFolder findByUUID_G( 282 java.lang.String uuid, long groupId) 283 throws com.liferay.portal.kernel.exception.SystemException, 284 com.liferay.portlet.journal.NoSuchFolderException { 285 return getPersistence().findByUUID_G(uuid, groupId); 286 } 287 288 /** 289 * Returns the journal folder where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 290 * 291 * @param uuid the uuid 292 * @param groupId the group ID 293 * @return the matching journal folder, or <code>null</code> if a matching journal folder could not be found 294 * @throws SystemException if a system exception occurred 295 */ 296 public static com.liferay.portlet.journal.model.JournalFolder fetchByUUID_G( 297 java.lang.String uuid, long groupId) 298 throws com.liferay.portal.kernel.exception.SystemException { 299 return getPersistence().fetchByUUID_G(uuid, groupId); 300 } 301 302 /** 303 * Returns the journal folder where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 304 * 305 * @param uuid the uuid 306 * @param groupId the group ID 307 * @param retrieveFromCache whether to use the finder cache 308 * @return the matching journal folder, or <code>null</code> if a matching journal folder could not be found 309 * @throws SystemException if a system exception occurred 310 */ 311 public static com.liferay.portlet.journal.model.JournalFolder fetchByUUID_G( 312 java.lang.String uuid, long groupId, boolean retrieveFromCache) 313 throws com.liferay.portal.kernel.exception.SystemException { 314 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 315 } 316 317 /** 318 * Removes the journal folder where uuid = ? and groupId = ? from the database. 319 * 320 * @param uuid the uuid 321 * @param groupId the group ID 322 * @return the journal folder that was removed 323 * @throws SystemException if a system exception occurred 324 */ 325 public static com.liferay.portlet.journal.model.JournalFolder removeByUUID_G( 326 java.lang.String uuid, long groupId) 327 throws com.liferay.portal.kernel.exception.SystemException, 328 com.liferay.portlet.journal.NoSuchFolderException { 329 return getPersistence().removeByUUID_G(uuid, groupId); 330 } 331 332 /** 333 * Returns the number of journal folders where uuid = ? and groupId = ?. 334 * 335 * @param uuid the uuid 336 * @param groupId the group ID 337 * @return the number of matching journal folders 338 * @throws SystemException if a system exception occurred 339 */ 340 public static int countByUUID_G(java.lang.String uuid, long groupId) 341 throws com.liferay.portal.kernel.exception.SystemException { 342 return getPersistence().countByUUID_G(uuid, groupId); 343 } 344 345 /** 346 * Returns all the journal folders where uuid = ? and companyId = ?. 347 * 348 * @param uuid the uuid 349 * @param companyId the company ID 350 * @return the matching journal folders 351 * @throws SystemException if a system exception occurred 352 */ 353 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByUuid_C( 354 java.lang.String uuid, long companyId) 355 throws com.liferay.portal.kernel.exception.SystemException { 356 return getPersistence().findByUuid_C(uuid, companyId); 357 } 358 359 /** 360 * Returns a range of all the journal folders where uuid = ? and companyId = ?. 361 * 362 * <p> 363 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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. 364 * </p> 365 * 366 * @param uuid the uuid 367 * @param companyId the company ID 368 * @param start the lower bound of the range of journal folders 369 * @param end the upper bound of the range of journal folders (not inclusive) 370 * @return the range of matching journal folders 371 * @throws SystemException if a system exception occurred 372 */ 373 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByUuid_C( 374 java.lang.String uuid, long companyId, int start, int end) 375 throws com.liferay.portal.kernel.exception.SystemException { 376 return getPersistence().findByUuid_C(uuid, companyId, start, end); 377 } 378 379 /** 380 * Returns an ordered range of all the journal folders where uuid = ? and companyId = ?. 381 * 382 * <p> 383 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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. 384 * </p> 385 * 386 * @param uuid the uuid 387 * @param companyId the company ID 388 * @param start the lower bound of the range of journal folders 389 * @param end the upper bound of the range of journal folders (not inclusive) 390 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 391 * @return the ordered range of matching journal folders 392 * @throws SystemException if a system exception occurred 393 */ 394 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByUuid_C( 395 java.lang.String uuid, long companyId, int start, int end, 396 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 397 throws com.liferay.portal.kernel.exception.SystemException { 398 return getPersistence() 399 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 400 } 401 402 /** 403 * Returns the first journal folder in the ordered set where uuid = ? and companyId = ?. 404 * 405 * @param uuid the uuid 406 * @param companyId the company ID 407 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 408 * @return the first matching journal folder 409 * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found 410 * @throws SystemException if a system exception occurred 411 */ 412 public static com.liferay.portlet.journal.model.JournalFolder findByUuid_C_First( 413 java.lang.String uuid, long companyId, 414 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 415 throws com.liferay.portal.kernel.exception.SystemException, 416 com.liferay.portlet.journal.NoSuchFolderException { 417 return getPersistence() 418 .findByUuid_C_First(uuid, companyId, orderByComparator); 419 } 420 421 /** 422 * Returns the first journal folder in the ordered set where uuid = ? and companyId = ?. 423 * 424 * @param uuid the uuid 425 * @param companyId the company ID 426 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 427 * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found 428 * @throws SystemException if a system exception occurred 429 */ 430 public static com.liferay.portlet.journal.model.JournalFolder fetchByUuid_C_First( 431 java.lang.String uuid, long companyId, 432 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 433 throws com.liferay.portal.kernel.exception.SystemException { 434 return getPersistence() 435 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 436 } 437 438 /** 439 * Returns the last journal folder in the ordered set where uuid = ? and companyId = ?. 440 * 441 * @param uuid the uuid 442 * @param companyId the company ID 443 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 444 * @return the last matching journal folder 445 * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found 446 * @throws SystemException if a system exception occurred 447 */ 448 public static com.liferay.portlet.journal.model.JournalFolder findByUuid_C_Last( 449 java.lang.String uuid, long companyId, 450 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 451 throws com.liferay.portal.kernel.exception.SystemException, 452 com.liferay.portlet.journal.NoSuchFolderException { 453 return getPersistence() 454 .findByUuid_C_Last(uuid, companyId, orderByComparator); 455 } 456 457 /** 458 * Returns the last journal folder in the ordered set where uuid = ? and companyId = ?. 459 * 460 * @param uuid the uuid 461 * @param companyId the company ID 462 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 463 * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found 464 * @throws SystemException if a system exception occurred 465 */ 466 public static com.liferay.portlet.journal.model.JournalFolder fetchByUuid_C_Last( 467 java.lang.String uuid, long companyId, 468 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 469 throws com.liferay.portal.kernel.exception.SystemException { 470 return getPersistence() 471 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 472 } 473 474 /** 475 * Returns the journal folders before and after the current journal folder in the ordered set where uuid = ? and companyId = ?. 476 * 477 * @param folderId the primary key of the current journal folder 478 * @param uuid the uuid 479 * @param companyId the company ID 480 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 481 * @return the previous, current, and next journal folder 482 * @throws com.liferay.portlet.journal.NoSuchFolderException if a journal folder with the primary key could not be found 483 * @throws SystemException if a system exception occurred 484 */ 485 public static com.liferay.portlet.journal.model.JournalFolder[] findByUuid_C_PrevAndNext( 486 long folderId, java.lang.String uuid, long companyId, 487 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 488 throws com.liferay.portal.kernel.exception.SystemException, 489 com.liferay.portlet.journal.NoSuchFolderException { 490 return getPersistence() 491 .findByUuid_C_PrevAndNext(folderId, uuid, companyId, 492 orderByComparator); 493 } 494 495 /** 496 * Removes all the journal folders where uuid = ? and companyId = ? from the database. 497 * 498 * @param uuid the uuid 499 * @param companyId the company ID 500 * @throws SystemException if a system exception occurred 501 */ 502 public static void removeByUuid_C(java.lang.String uuid, long companyId) 503 throws com.liferay.portal.kernel.exception.SystemException { 504 getPersistence().removeByUuid_C(uuid, companyId); 505 } 506 507 /** 508 * Returns the number of journal folders where uuid = ? and companyId = ?. 509 * 510 * @param uuid the uuid 511 * @param companyId the company ID 512 * @return the number of matching journal folders 513 * @throws SystemException if a system exception occurred 514 */ 515 public static int countByUuid_C(java.lang.String uuid, long companyId) 516 throws com.liferay.portal.kernel.exception.SystemException { 517 return getPersistence().countByUuid_C(uuid, companyId); 518 } 519 520 /** 521 * Returns all the journal folders where groupId = ?. 522 * 523 * @param groupId the group ID 524 * @return the matching journal folders 525 * @throws SystemException if a system exception occurred 526 */ 527 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByGroupId( 528 long groupId) 529 throws com.liferay.portal.kernel.exception.SystemException { 530 return getPersistence().findByGroupId(groupId); 531 } 532 533 /** 534 * Returns a range of all the journal folders where groupId = ?. 535 * 536 * <p> 537 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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. 538 * </p> 539 * 540 * @param groupId the group ID 541 * @param start the lower bound of the range of journal folders 542 * @param end the upper bound of the range of journal folders (not inclusive) 543 * @return the range of matching journal folders 544 * @throws SystemException if a system exception occurred 545 */ 546 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByGroupId( 547 long groupId, int start, int end) 548 throws com.liferay.portal.kernel.exception.SystemException { 549 return getPersistence().findByGroupId(groupId, start, end); 550 } 551 552 /** 553 * Returns an ordered range of all the journal folders where groupId = ?. 554 * 555 * <p> 556 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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. 557 * </p> 558 * 559 * @param groupId the group ID 560 * @param start the lower bound of the range of journal folders 561 * @param end the upper bound of the range of journal folders (not inclusive) 562 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 563 * @return the ordered range of matching journal folders 564 * @throws SystemException if a system exception occurred 565 */ 566 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByGroupId( 567 long groupId, int start, int end, 568 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 569 throws com.liferay.portal.kernel.exception.SystemException { 570 return getPersistence() 571 .findByGroupId(groupId, start, end, orderByComparator); 572 } 573 574 /** 575 * Returns the first journal folder in the ordered set where groupId = ?. 576 * 577 * @param groupId the group ID 578 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 579 * @return the first matching journal folder 580 * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found 581 * @throws SystemException if a system exception occurred 582 */ 583 public static com.liferay.portlet.journal.model.JournalFolder findByGroupId_First( 584 long groupId, 585 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 586 throws com.liferay.portal.kernel.exception.SystemException, 587 com.liferay.portlet.journal.NoSuchFolderException { 588 return getPersistence().findByGroupId_First(groupId, orderByComparator); 589 } 590 591 /** 592 * Returns the first journal folder in the ordered set where groupId = ?. 593 * 594 * @param groupId the group ID 595 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 596 * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found 597 * @throws SystemException if a system exception occurred 598 */ 599 public static com.liferay.portlet.journal.model.JournalFolder fetchByGroupId_First( 600 long groupId, 601 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 602 throws com.liferay.portal.kernel.exception.SystemException { 603 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 604 } 605 606 /** 607 * Returns the last journal folder in the ordered set where groupId = ?. 608 * 609 * @param groupId the group ID 610 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 611 * @return the last matching journal folder 612 * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found 613 * @throws SystemException if a system exception occurred 614 */ 615 public static com.liferay.portlet.journal.model.JournalFolder findByGroupId_Last( 616 long groupId, 617 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 618 throws com.liferay.portal.kernel.exception.SystemException, 619 com.liferay.portlet.journal.NoSuchFolderException { 620 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 621 } 622 623 /** 624 * Returns the last journal folder in the ordered set where groupId = ?. 625 * 626 * @param groupId the group ID 627 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 628 * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found 629 * @throws SystemException if a system exception occurred 630 */ 631 public static com.liferay.portlet.journal.model.JournalFolder fetchByGroupId_Last( 632 long groupId, 633 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 634 throws com.liferay.portal.kernel.exception.SystemException { 635 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 636 } 637 638 /** 639 * Returns the journal folders before and after the current journal folder in the ordered set where groupId = ?. 640 * 641 * @param folderId the primary key of the current journal folder 642 * @param groupId the group ID 643 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 644 * @return the previous, current, and next journal folder 645 * @throws com.liferay.portlet.journal.NoSuchFolderException if a journal folder with the primary key could not be found 646 * @throws SystemException if a system exception occurred 647 */ 648 public static com.liferay.portlet.journal.model.JournalFolder[] findByGroupId_PrevAndNext( 649 long folderId, long groupId, 650 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 651 throws com.liferay.portal.kernel.exception.SystemException, 652 com.liferay.portlet.journal.NoSuchFolderException { 653 return getPersistence() 654 .findByGroupId_PrevAndNext(folderId, groupId, 655 orderByComparator); 656 } 657 658 /** 659 * Returns all the journal folders that the user has permission to view where groupId = ?. 660 * 661 * @param groupId the group ID 662 * @return the matching journal folders that the user has permission to view 663 * @throws SystemException if a system exception occurred 664 */ 665 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> filterFindByGroupId( 666 long groupId) 667 throws com.liferay.portal.kernel.exception.SystemException { 668 return getPersistence().filterFindByGroupId(groupId); 669 } 670 671 /** 672 * Returns a range of all the journal folders that the user has permission to view where groupId = ?. 673 * 674 * <p> 675 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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. 676 * </p> 677 * 678 * @param groupId the group ID 679 * @param start the lower bound of the range of journal folders 680 * @param end the upper bound of the range of journal folders (not inclusive) 681 * @return the range of matching journal folders that the user has permission to view 682 * @throws SystemException if a system exception occurred 683 */ 684 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> filterFindByGroupId( 685 long groupId, int start, int end) 686 throws com.liferay.portal.kernel.exception.SystemException { 687 return getPersistence().filterFindByGroupId(groupId, start, end); 688 } 689 690 /** 691 * Returns an ordered range of all the journal folders that the user has permissions to view where groupId = ?. 692 * 693 * <p> 694 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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. 695 * </p> 696 * 697 * @param groupId the group ID 698 * @param start the lower bound of the range of journal folders 699 * @param end the upper bound of the range of journal folders (not inclusive) 700 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 701 * @return the ordered range of matching journal folders that the user has permission to view 702 * @throws SystemException if a system exception occurred 703 */ 704 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> filterFindByGroupId( 705 long groupId, int start, int end, 706 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 707 throws com.liferay.portal.kernel.exception.SystemException { 708 return getPersistence() 709 .filterFindByGroupId(groupId, start, end, orderByComparator); 710 } 711 712 /** 713 * 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 = ?. 714 * 715 * @param folderId the primary key of the current journal folder 716 * @param groupId the group ID 717 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 718 * @return the previous, current, and next journal folder 719 * @throws com.liferay.portlet.journal.NoSuchFolderException if a journal folder with the primary key could not be found 720 * @throws SystemException if a system exception occurred 721 */ 722 public static com.liferay.portlet.journal.model.JournalFolder[] filterFindByGroupId_PrevAndNext( 723 long folderId, long groupId, 724 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 725 throws com.liferay.portal.kernel.exception.SystemException, 726 com.liferay.portlet.journal.NoSuchFolderException { 727 return getPersistence() 728 .filterFindByGroupId_PrevAndNext(folderId, groupId, 729 orderByComparator); 730 } 731 732 /** 733 * Removes all the journal folders where groupId = ? from the database. 734 * 735 * @param groupId the group ID 736 * @throws SystemException if a system exception occurred 737 */ 738 public static void removeByGroupId(long groupId) 739 throws com.liferay.portal.kernel.exception.SystemException { 740 getPersistence().removeByGroupId(groupId); 741 } 742 743 /** 744 * Returns the number of journal folders where groupId = ?. 745 * 746 * @param groupId the group ID 747 * @return the number of matching journal folders 748 * @throws SystemException if a system exception occurred 749 */ 750 public static int countByGroupId(long groupId) 751 throws com.liferay.portal.kernel.exception.SystemException { 752 return getPersistence().countByGroupId(groupId); 753 } 754 755 /** 756 * Returns the number of journal folders that the user has permission to view where groupId = ?. 757 * 758 * @param groupId the group ID 759 * @return the number of matching journal folders that the user has permission to view 760 * @throws SystemException if a system exception occurred 761 */ 762 public static int filterCountByGroupId(long groupId) 763 throws com.liferay.portal.kernel.exception.SystemException { 764 return getPersistence().filterCountByGroupId(groupId); 765 } 766 767 /** 768 * Returns all the journal folders where companyId = ?. 769 * 770 * @param companyId the company ID 771 * @return the matching journal folders 772 * @throws SystemException if a system exception occurred 773 */ 774 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByCompanyId( 775 long companyId) 776 throws com.liferay.portal.kernel.exception.SystemException { 777 return getPersistence().findByCompanyId(companyId); 778 } 779 780 /** 781 * Returns a range of all the journal folders where companyId = ?. 782 * 783 * <p> 784 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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. 785 * </p> 786 * 787 * @param companyId the company ID 788 * @param start the lower bound of the range of journal folders 789 * @param end the upper bound of the range of journal folders (not inclusive) 790 * @return the range of matching journal folders 791 * @throws SystemException if a system exception occurred 792 */ 793 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByCompanyId( 794 long companyId, int start, int end) 795 throws com.liferay.portal.kernel.exception.SystemException { 796 return getPersistence().findByCompanyId(companyId, start, end); 797 } 798 799 /** 800 * Returns an ordered range of all the journal folders where companyId = ?. 801 * 802 * <p> 803 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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. 804 * </p> 805 * 806 * @param companyId the company ID 807 * @param start the lower bound of the range of journal folders 808 * @param end the upper bound of the range of journal folders (not inclusive) 809 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 810 * @return the ordered range of matching journal folders 811 * @throws SystemException if a system exception occurred 812 */ 813 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByCompanyId( 814 long companyId, int start, int end, 815 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 816 throws com.liferay.portal.kernel.exception.SystemException { 817 return getPersistence() 818 .findByCompanyId(companyId, start, end, orderByComparator); 819 } 820 821 /** 822 * Returns the first journal folder in the ordered set where companyId = ?. 823 * 824 * @param companyId the company ID 825 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 826 * @return the first matching journal folder 827 * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found 828 * @throws SystemException if a system exception occurred 829 */ 830 public static com.liferay.portlet.journal.model.JournalFolder findByCompanyId_First( 831 long companyId, 832 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 833 throws com.liferay.portal.kernel.exception.SystemException, 834 com.liferay.portlet.journal.NoSuchFolderException { 835 return getPersistence() 836 .findByCompanyId_First(companyId, orderByComparator); 837 } 838 839 /** 840 * Returns the first journal folder in the ordered set where companyId = ?. 841 * 842 * @param companyId the company ID 843 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 844 * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found 845 * @throws SystemException if a system exception occurred 846 */ 847 public static com.liferay.portlet.journal.model.JournalFolder fetchByCompanyId_First( 848 long companyId, 849 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 850 throws com.liferay.portal.kernel.exception.SystemException { 851 return getPersistence() 852 .fetchByCompanyId_First(companyId, orderByComparator); 853 } 854 855 /** 856 * Returns the last journal folder in the ordered set where companyId = ?. 857 * 858 * @param companyId the company ID 859 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 860 * @return the last matching journal folder 861 * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found 862 * @throws SystemException if a system exception occurred 863 */ 864 public static com.liferay.portlet.journal.model.JournalFolder findByCompanyId_Last( 865 long companyId, 866 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 867 throws com.liferay.portal.kernel.exception.SystemException, 868 com.liferay.portlet.journal.NoSuchFolderException { 869 return getPersistence() 870 .findByCompanyId_Last(companyId, orderByComparator); 871 } 872 873 /** 874 * Returns the last journal folder in the ordered set where companyId = ?. 875 * 876 * @param companyId the company ID 877 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 878 * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found 879 * @throws SystemException if a system exception occurred 880 */ 881 public static com.liferay.portlet.journal.model.JournalFolder fetchByCompanyId_Last( 882 long companyId, 883 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 884 throws com.liferay.portal.kernel.exception.SystemException { 885 return getPersistence() 886 .fetchByCompanyId_Last(companyId, orderByComparator); 887 } 888 889 /** 890 * Returns the journal folders before and after the current journal folder in the ordered set where companyId = ?. 891 * 892 * @param folderId the primary key of the current journal folder 893 * @param companyId the company ID 894 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 895 * @return the previous, current, and next journal folder 896 * @throws com.liferay.portlet.journal.NoSuchFolderException if a journal folder with the primary key could not be found 897 * @throws SystemException if a system exception occurred 898 */ 899 public static com.liferay.portlet.journal.model.JournalFolder[] findByCompanyId_PrevAndNext( 900 long folderId, long companyId, 901 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 902 throws com.liferay.portal.kernel.exception.SystemException, 903 com.liferay.portlet.journal.NoSuchFolderException { 904 return getPersistence() 905 .findByCompanyId_PrevAndNext(folderId, companyId, 906 orderByComparator); 907 } 908 909 /** 910 * Removes all the journal folders where companyId = ? from the database. 911 * 912 * @param companyId the company ID 913 * @throws SystemException if a system exception occurred 914 */ 915 public static void removeByCompanyId(long companyId) 916 throws com.liferay.portal.kernel.exception.SystemException { 917 getPersistence().removeByCompanyId(companyId); 918 } 919 920 /** 921 * Returns the number of journal folders where companyId = ?. 922 * 923 * @param companyId the company ID 924 * @return the number of matching journal folders 925 * @throws SystemException if a system exception occurred 926 */ 927 public static int countByCompanyId(long companyId) 928 throws com.liferay.portal.kernel.exception.SystemException { 929 return getPersistence().countByCompanyId(companyId); 930 } 931 932 /** 933 * Returns all the journal folders where groupId = ? and parentFolderId = ?. 934 * 935 * @param groupId the group ID 936 * @param parentFolderId the parent folder ID 937 * @return the matching journal folders 938 * @throws SystemException if a system exception occurred 939 */ 940 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByG_P( 941 long groupId, long parentFolderId) 942 throws com.liferay.portal.kernel.exception.SystemException { 943 return getPersistence().findByG_P(groupId, parentFolderId); 944 } 945 946 /** 947 * Returns a range of all the journal folders where groupId = ? and parentFolderId = ?. 948 * 949 * <p> 950 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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. 951 * </p> 952 * 953 * @param groupId the group ID 954 * @param parentFolderId the parent folder ID 955 * @param start the lower bound of the range of journal folders 956 * @param end the upper bound of the range of journal folders (not inclusive) 957 * @return the range of matching journal folders 958 * @throws SystemException if a system exception occurred 959 */ 960 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByG_P( 961 long groupId, long parentFolderId, int start, int end) 962 throws com.liferay.portal.kernel.exception.SystemException { 963 return getPersistence().findByG_P(groupId, parentFolderId, start, end); 964 } 965 966 /** 967 * Returns an ordered range of all the journal folders where groupId = ? and parentFolderId = ?. 968 * 969 * <p> 970 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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. 971 * </p> 972 * 973 * @param groupId the group ID 974 * @param parentFolderId the parent folder ID 975 * @param start the lower bound of the range of journal folders 976 * @param end the upper bound of the range of journal folders (not inclusive) 977 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 978 * @return the ordered range of matching journal folders 979 * @throws SystemException if a system exception occurred 980 */ 981 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByG_P( 982 long groupId, long parentFolderId, int start, int end, 983 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 984 throws com.liferay.portal.kernel.exception.SystemException { 985 return getPersistence() 986 .findByG_P(groupId, parentFolderId, start, end, 987 orderByComparator); 988 } 989 990 /** 991 * Returns the first journal folder in the ordered set where groupId = ? and parentFolderId = ?. 992 * 993 * @param groupId the group ID 994 * @param parentFolderId the parent folder ID 995 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 996 * @return the first matching journal folder 997 * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found 998 * @throws SystemException if a system exception occurred 999 */ 1000 public static com.liferay.portlet.journal.model.JournalFolder findByG_P_First( 1001 long groupId, long parentFolderId, 1002 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1003 throws com.liferay.portal.kernel.exception.SystemException, 1004 com.liferay.portlet.journal.NoSuchFolderException { 1005 return getPersistence() 1006 .findByG_P_First(groupId, parentFolderId, orderByComparator); 1007 } 1008 1009 /** 1010 * Returns the first journal folder in the ordered set where groupId = ? and parentFolderId = ?. 1011 * 1012 * @param groupId the group ID 1013 * @param parentFolderId the parent folder ID 1014 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1015 * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found 1016 * @throws SystemException if a system exception occurred 1017 */ 1018 public static com.liferay.portlet.journal.model.JournalFolder fetchByG_P_First( 1019 long groupId, long parentFolderId, 1020 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1021 throws com.liferay.portal.kernel.exception.SystemException { 1022 return getPersistence() 1023 .fetchByG_P_First(groupId, parentFolderId, orderByComparator); 1024 } 1025 1026 /** 1027 * Returns the last journal folder in the ordered set where groupId = ? and parentFolderId = ?. 1028 * 1029 * @param groupId the group ID 1030 * @param parentFolderId the parent folder ID 1031 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1032 * @return the last matching journal folder 1033 * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found 1034 * @throws SystemException if a system exception occurred 1035 */ 1036 public static com.liferay.portlet.journal.model.JournalFolder findByG_P_Last( 1037 long groupId, long parentFolderId, 1038 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1039 throws com.liferay.portal.kernel.exception.SystemException, 1040 com.liferay.portlet.journal.NoSuchFolderException { 1041 return getPersistence() 1042 .findByG_P_Last(groupId, parentFolderId, orderByComparator); 1043 } 1044 1045 /** 1046 * Returns the last journal folder in the ordered set where groupId = ? and parentFolderId = ?. 1047 * 1048 * @param groupId the group ID 1049 * @param parentFolderId the parent folder ID 1050 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1051 * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found 1052 * @throws SystemException if a system exception occurred 1053 */ 1054 public static com.liferay.portlet.journal.model.JournalFolder fetchByG_P_Last( 1055 long groupId, long parentFolderId, 1056 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1057 throws com.liferay.portal.kernel.exception.SystemException { 1058 return getPersistence() 1059 .fetchByG_P_Last(groupId, parentFolderId, orderByComparator); 1060 } 1061 1062 /** 1063 * Returns the journal folders before and after the current journal folder in the ordered set where groupId = ? and parentFolderId = ?. 1064 * 1065 * @param folderId the primary key of the current journal folder 1066 * @param groupId the group ID 1067 * @param parentFolderId the parent folder ID 1068 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1069 * @return the previous, current, and next journal folder 1070 * @throws com.liferay.portlet.journal.NoSuchFolderException if a journal folder with the primary key could not be found 1071 * @throws SystemException if a system exception occurred 1072 */ 1073 public static com.liferay.portlet.journal.model.JournalFolder[] findByG_P_PrevAndNext( 1074 long folderId, long groupId, long parentFolderId, 1075 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1076 throws com.liferay.portal.kernel.exception.SystemException, 1077 com.liferay.portlet.journal.NoSuchFolderException { 1078 return getPersistence() 1079 .findByG_P_PrevAndNext(folderId, groupId, parentFolderId, 1080 orderByComparator); 1081 } 1082 1083 /** 1084 * Returns all the journal folders that the user has permission to view where groupId = ? and parentFolderId = ?. 1085 * 1086 * @param groupId the group ID 1087 * @param parentFolderId the parent folder ID 1088 * @return the matching journal folders that the user has permission to view 1089 * @throws SystemException if a system exception occurred 1090 */ 1091 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> filterFindByG_P( 1092 long groupId, long parentFolderId) 1093 throws com.liferay.portal.kernel.exception.SystemException { 1094 return getPersistence().filterFindByG_P(groupId, parentFolderId); 1095 } 1096 1097 /** 1098 * Returns a range of all the journal folders that the user has permission to view where groupId = ? and parentFolderId = ?. 1099 * 1100 * <p> 1101 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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. 1102 * </p> 1103 * 1104 * @param groupId the group ID 1105 * @param parentFolderId the parent folder ID 1106 * @param start the lower bound of the range of journal folders 1107 * @param end the upper bound of the range of journal folders (not inclusive) 1108 * @return the range of matching journal folders that the user has permission to view 1109 * @throws SystemException if a system exception occurred 1110 */ 1111 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> filterFindByG_P( 1112 long groupId, long parentFolderId, int start, int end) 1113 throws com.liferay.portal.kernel.exception.SystemException { 1114 return getPersistence() 1115 .filterFindByG_P(groupId, parentFolderId, start, end); 1116 } 1117 1118 /** 1119 * Returns an ordered range of all the journal folders that the user has permissions to view where groupId = ? and parentFolderId = ?. 1120 * 1121 * <p> 1122 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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. 1123 * </p> 1124 * 1125 * @param groupId the group ID 1126 * @param parentFolderId the parent folder ID 1127 * @param start the lower bound of the range of journal folders 1128 * @param end the upper bound of the range of journal folders (not inclusive) 1129 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1130 * @return the ordered range of matching journal folders that the user has permission to view 1131 * @throws SystemException if a system exception occurred 1132 */ 1133 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> filterFindByG_P( 1134 long groupId, long parentFolderId, int start, int end, 1135 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1136 throws com.liferay.portal.kernel.exception.SystemException { 1137 return getPersistence() 1138 .filterFindByG_P(groupId, parentFolderId, start, end, 1139 orderByComparator); 1140 } 1141 1142 /** 1143 * 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 = ?. 1144 * 1145 * @param folderId the primary key of the current journal folder 1146 * @param groupId the group ID 1147 * @param parentFolderId the parent folder ID 1148 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1149 * @return the previous, current, and next journal folder 1150 * @throws com.liferay.portlet.journal.NoSuchFolderException if a journal folder with the primary key could not be found 1151 * @throws SystemException if a system exception occurred 1152 */ 1153 public static com.liferay.portlet.journal.model.JournalFolder[] filterFindByG_P_PrevAndNext( 1154 long folderId, long groupId, long parentFolderId, 1155 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1156 throws com.liferay.portal.kernel.exception.SystemException, 1157 com.liferay.portlet.journal.NoSuchFolderException { 1158 return getPersistence() 1159 .filterFindByG_P_PrevAndNext(folderId, groupId, 1160 parentFolderId, orderByComparator); 1161 } 1162 1163 /** 1164 * Removes all the journal folders where groupId = ? and parentFolderId = ? from the database. 1165 * 1166 * @param groupId the group ID 1167 * @param parentFolderId the parent folder ID 1168 * @throws SystemException if a system exception occurred 1169 */ 1170 public static void removeByG_P(long groupId, long parentFolderId) 1171 throws com.liferay.portal.kernel.exception.SystemException { 1172 getPersistence().removeByG_P(groupId, parentFolderId); 1173 } 1174 1175 /** 1176 * Returns the number of journal folders where groupId = ? and parentFolderId = ?. 1177 * 1178 * @param groupId the group ID 1179 * @param parentFolderId the parent folder ID 1180 * @return the number of matching journal folders 1181 * @throws SystemException if a system exception occurred 1182 */ 1183 public static int countByG_P(long groupId, long parentFolderId) 1184 throws com.liferay.portal.kernel.exception.SystemException { 1185 return getPersistence().countByG_P(groupId, parentFolderId); 1186 } 1187 1188 /** 1189 * Returns the number of journal folders that the user has permission to view where groupId = ? and parentFolderId = ?. 1190 * 1191 * @param groupId the group ID 1192 * @param parentFolderId the parent folder ID 1193 * @return the number of matching journal folders that the user has permission to view 1194 * @throws SystemException if a system exception occurred 1195 */ 1196 public static int filterCountByG_P(long groupId, long parentFolderId) 1197 throws com.liferay.portal.kernel.exception.SystemException { 1198 return getPersistence().filterCountByG_P(groupId, parentFolderId); 1199 } 1200 1201 /** 1202 * Returns the journal folder where groupId = ? and name = ? or throws a {@link com.liferay.portlet.journal.NoSuchFolderException} if it could not be found. 1203 * 1204 * @param groupId the group ID 1205 * @param name the name 1206 * @return the matching journal folder 1207 * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found 1208 * @throws SystemException if a system exception occurred 1209 */ 1210 public static com.liferay.portlet.journal.model.JournalFolder findByG_N( 1211 long groupId, java.lang.String name) 1212 throws com.liferay.portal.kernel.exception.SystemException, 1213 com.liferay.portlet.journal.NoSuchFolderException { 1214 return getPersistence().findByG_N(groupId, name); 1215 } 1216 1217 /** 1218 * Returns the journal folder where groupId = ? and name = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 1219 * 1220 * @param groupId the group ID 1221 * @param name the name 1222 * @return the matching journal folder, or <code>null</code> if a matching journal folder could not be found 1223 * @throws SystemException if a system exception occurred 1224 */ 1225 public static com.liferay.portlet.journal.model.JournalFolder fetchByG_N( 1226 long groupId, java.lang.String name) 1227 throws com.liferay.portal.kernel.exception.SystemException { 1228 return getPersistence().fetchByG_N(groupId, name); 1229 } 1230 1231 /** 1232 * Returns the journal folder where groupId = ? and name = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 1233 * 1234 * @param groupId the group ID 1235 * @param name the name 1236 * @param retrieveFromCache whether to use the finder cache 1237 * @return the matching journal folder, or <code>null</code> if a matching journal folder could not be found 1238 * @throws SystemException if a system exception occurred 1239 */ 1240 public static com.liferay.portlet.journal.model.JournalFolder fetchByG_N( 1241 long groupId, java.lang.String name, boolean retrieveFromCache) 1242 throws com.liferay.portal.kernel.exception.SystemException { 1243 return getPersistence().fetchByG_N(groupId, name, retrieveFromCache); 1244 } 1245 1246 /** 1247 * Removes the journal folder where groupId = ? and name = ? from the database. 1248 * 1249 * @param groupId the group ID 1250 * @param name the name 1251 * @return the journal folder that was removed 1252 * @throws SystemException if a system exception occurred 1253 */ 1254 public static com.liferay.portlet.journal.model.JournalFolder removeByG_N( 1255 long groupId, java.lang.String name) 1256 throws com.liferay.portal.kernel.exception.SystemException, 1257 com.liferay.portlet.journal.NoSuchFolderException { 1258 return getPersistence().removeByG_N(groupId, name); 1259 } 1260 1261 /** 1262 * Returns the number of journal folders where groupId = ? and name = ?. 1263 * 1264 * @param groupId the group ID 1265 * @param name the name 1266 * @return the number of matching journal folders 1267 * @throws SystemException if a system exception occurred 1268 */ 1269 public static int countByG_N(long groupId, java.lang.String name) 1270 throws com.liferay.portal.kernel.exception.SystemException { 1271 return getPersistence().countByG_N(groupId, name); 1272 } 1273 1274 /** 1275 * Returns the journal folder where groupId = ? and parentFolderId = ? and name = ? or throws a {@link com.liferay.portlet.journal.NoSuchFolderException} if it could not be found. 1276 * 1277 * @param groupId the group ID 1278 * @param parentFolderId the parent folder ID 1279 * @param name the name 1280 * @return the matching journal folder 1281 * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found 1282 * @throws SystemException if a system exception occurred 1283 */ 1284 public static com.liferay.portlet.journal.model.JournalFolder findByG_P_N( 1285 long groupId, long parentFolderId, java.lang.String name) 1286 throws com.liferay.portal.kernel.exception.SystemException, 1287 com.liferay.portlet.journal.NoSuchFolderException { 1288 return getPersistence().findByG_P_N(groupId, parentFolderId, name); 1289 } 1290 1291 /** 1292 * 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. 1293 * 1294 * @param groupId the group ID 1295 * @param parentFolderId the parent folder ID 1296 * @param name the name 1297 * @return the matching journal folder, or <code>null</code> if a matching journal folder could not be found 1298 * @throws SystemException if a system exception occurred 1299 */ 1300 public static com.liferay.portlet.journal.model.JournalFolder fetchByG_P_N( 1301 long groupId, long parentFolderId, java.lang.String name) 1302 throws com.liferay.portal.kernel.exception.SystemException { 1303 return getPersistence().fetchByG_P_N(groupId, parentFolderId, name); 1304 } 1305 1306 /** 1307 * 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. 1308 * 1309 * @param groupId the group ID 1310 * @param parentFolderId the parent folder ID 1311 * @param name the name 1312 * @param retrieveFromCache whether to use the finder cache 1313 * @return the matching journal folder, or <code>null</code> if a matching journal folder could not be found 1314 * @throws SystemException if a system exception occurred 1315 */ 1316 public static com.liferay.portlet.journal.model.JournalFolder fetchByG_P_N( 1317 long groupId, long parentFolderId, java.lang.String name, 1318 boolean retrieveFromCache) 1319 throws com.liferay.portal.kernel.exception.SystemException { 1320 return getPersistence() 1321 .fetchByG_P_N(groupId, parentFolderId, name, 1322 retrieveFromCache); 1323 } 1324 1325 /** 1326 * Removes the journal folder where groupId = ? and parentFolderId = ? and name = ? from the database. 1327 * 1328 * @param groupId the group ID 1329 * @param parentFolderId the parent folder ID 1330 * @param name the name 1331 * @return the journal folder that was removed 1332 * @throws SystemException if a system exception occurred 1333 */ 1334 public static com.liferay.portlet.journal.model.JournalFolder removeByG_P_N( 1335 long groupId, long parentFolderId, java.lang.String name) 1336 throws com.liferay.portal.kernel.exception.SystemException, 1337 com.liferay.portlet.journal.NoSuchFolderException { 1338 return getPersistence().removeByG_P_N(groupId, parentFolderId, name); 1339 } 1340 1341 /** 1342 * Returns the number of journal folders where groupId = ? and parentFolderId = ? and name = ?. 1343 * 1344 * @param groupId the group ID 1345 * @param parentFolderId the parent folder ID 1346 * @param name the name 1347 * @return the number of matching journal folders 1348 * @throws SystemException if a system exception occurred 1349 */ 1350 public static int countByG_P_N(long groupId, long parentFolderId, 1351 java.lang.String name) 1352 throws com.liferay.portal.kernel.exception.SystemException { 1353 return getPersistence().countByG_P_N(groupId, parentFolderId, name); 1354 } 1355 1356 /** 1357 * Returns all the journal folders where groupId = ? and parentFolderId = ? and status = ?. 1358 * 1359 * @param groupId the group ID 1360 * @param parentFolderId the parent folder ID 1361 * @param status the status 1362 * @return the matching journal folders 1363 * @throws SystemException if a system exception occurred 1364 */ 1365 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByG_P_S( 1366 long groupId, long parentFolderId, int status) 1367 throws com.liferay.portal.kernel.exception.SystemException { 1368 return getPersistence().findByG_P_S(groupId, parentFolderId, status); 1369 } 1370 1371 /** 1372 * Returns a range of all the journal folders where groupId = ? and parentFolderId = ? and status = ?. 1373 * 1374 * <p> 1375 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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. 1376 * </p> 1377 * 1378 * @param groupId the group ID 1379 * @param parentFolderId the parent folder ID 1380 * @param status the status 1381 * @param start the lower bound of the range of journal folders 1382 * @param end the upper bound of the range of journal folders (not inclusive) 1383 * @return the range of matching journal folders 1384 * @throws SystemException if a system exception occurred 1385 */ 1386 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByG_P_S( 1387 long groupId, long parentFolderId, int status, int start, int end) 1388 throws com.liferay.portal.kernel.exception.SystemException { 1389 return getPersistence() 1390 .findByG_P_S(groupId, parentFolderId, status, start, end); 1391 } 1392 1393 /** 1394 * Returns an ordered range of all the journal folders where groupId = ? and parentFolderId = ? and status = ?. 1395 * 1396 * <p> 1397 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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. 1398 * </p> 1399 * 1400 * @param groupId the group ID 1401 * @param parentFolderId the parent folder ID 1402 * @param status the status 1403 * @param start the lower bound of the range of journal folders 1404 * @param end the upper bound of the range of journal folders (not inclusive) 1405 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1406 * @return the ordered range of matching journal folders 1407 * @throws SystemException if a system exception occurred 1408 */ 1409 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByG_P_S( 1410 long groupId, long parentFolderId, int status, int start, int end, 1411 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1412 throws com.liferay.portal.kernel.exception.SystemException { 1413 return getPersistence() 1414 .findByG_P_S(groupId, parentFolderId, status, start, end, 1415 orderByComparator); 1416 } 1417 1418 /** 1419 * Returns the first journal folder in the ordered set where groupId = ? and parentFolderId = ? and status = ?. 1420 * 1421 * @param groupId the group ID 1422 * @param parentFolderId the parent folder ID 1423 * @param status the status 1424 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1425 * @return the first matching journal folder 1426 * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found 1427 * @throws SystemException if a system exception occurred 1428 */ 1429 public static com.liferay.portlet.journal.model.JournalFolder findByG_P_S_First( 1430 long groupId, long parentFolderId, int status, 1431 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1432 throws com.liferay.portal.kernel.exception.SystemException, 1433 com.liferay.portlet.journal.NoSuchFolderException { 1434 return getPersistence() 1435 .findByG_P_S_First(groupId, parentFolderId, status, 1436 orderByComparator); 1437 } 1438 1439 /** 1440 * Returns the first journal folder in the ordered set where groupId = ? and parentFolderId = ? and status = ?. 1441 * 1442 * @param groupId the group ID 1443 * @param parentFolderId the parent folder ID 1444 * @param status the status 1445 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1446 * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found 1447 * @throws SystemException if a system exception occurred 1448 */ 1449 public static com.liferay.portlet.journal.model.JournalFolder fetchByG_P_S_First( 1450 long groupId, long parentFolderId, int status, 1451 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1452 throws com.liferay.portal.kernel.exception.SystemException { 1453 return getPersistence() 1454 .fetchByG_P_S_First(groupId, parentFolderId, status, 1455 orderByComparator); 1456 } 1457 1458 /** 1459 * Returns the last journal folder in the ordered set 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 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1465 * @return the last matching journal folder 1466 * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found 1467 * @throws SystemException if a system exception occurred 1468 */ 1469 public static com.liferay.portlet.journal.model.JournalFolder findByG_P_S_Last( 1470 long groupId, long parentFolderId, int status, 1471 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1472 throws com.liferay.portal.kernel.exception.SystemException, 1473 com.liferay.portlet.journal.NoSuchFolderException { 1474 return getPersistence() 1475 .findByG_P_S_Last(groupId, parentFolderId, status, 1476 orderByComparator); 1477 } 1478 1479 /** 1480 * Returns the last journal folder in the ordered set where groupId = ? and parentFolderId = ? and status = ?. 1481 * 1482 * @param groupId the group ID 1483 * @param parentFolderId the parent folder ID 1484 * @param status the status 1485 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1486 * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found 1487 * @throws SystemException if a system exception occurred 1488 */ 1489 public static com.liferay.portlet.journal.model.JournalFolder fetchByG_P_S_Last( 1490 long groupId, long parentFolderId, int status, 1491 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1492 throws com.liferay.portal.kernel.exception.SystemException { 1493 return getPersistence() 1494 .fetchByG_P_S_Last(groupId, parentFolderId, status, 1495 orderByComparator); 1496 } 1497 1498 /** 1499 * Returns the journal folders before and after the current journal folder in the ordered set where groupId = ? and parentFolderId = ? and status = ?. 1500 * 1501 * @param folderId the primary key of the current journal folder 1502 * @param groupId the group ID 1503 * @param parentFolderId the parent folder ID 1504 * @param status the status 1505 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1506 * @return the previous, current, and next journal folder 1507 * @throws com.liferay.portlet.journal.NoSuchFolderException if a journal folder with the primary key could not be found 1508 * @throws SystemException if a system exception occurred 1509 */ 1510 public static com.liferay.portlet.journal.model.JournalFolder[] findByG_P_S_PrevAndNext( 1511 long folderId, long groupId, long parentFolderId, int status, 1512 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1513 throws com.liferay.portal.kernel.exception.SystemException, 1514 com.liferay.portlet.journal.NoSuchFolderException { 1515 return getPersistence() 1516 .findByG_P_S_PrevAndNext(folderId, groupId, parentFolderId, 1517 status, orderByComparator); 1518 } 1519 1520 /** 1521 * Returns all the journal folders that the user has permission to view where groupId = ? and parentFolderId = ? and status = ?. 1522 * 1523 * @param groupId the group ID 1524 * @param parentFolderId the parent folder ID 1525 * @param status the status 1526 * @return the matching journal folders that the user has permission to view 1527 * @throws SystemException if a system exception occurred 1528 */ 1529 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> filterFindByG_P_S( 1530 long groupId, long parentFolderId, int status) 1531 throws com.liferay.portal.kernel.exception.SystemException { 1532 return getPersistence() 1533 .filterFindByG_P_S(groupId, parentFolderId, status); 1534 } 1535 1536 /** 1537 * Returns a range of all the journal folders that the user has permission to view where groupId = ? and parentFolderId = ? and status = ?. 1538 * 1539 * <p> 1540 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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. 1541 * </p> 1542 * 1543 * @param groupId the group ID 1544 * @param parentFolderId the parent folder ID 1545 * @param status the status 1546 * @param start the lower bound of the range of journal folders 1547 * @param end the upper bound of the range of journal folders (not inclusive) 1548 * @return the range of matching journal folders that the user has permission to view 1549 * @throws SystemException if a system exception occurred 1550 */ 1551 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> filterFindByG_P_S( 1552 long groupId, long parentFolderId, int status, int start, int end) 1553 throws com.liferay.portal.kernel.exception.SystemException { 1554 return getPersistence() 1555 .filterFindByG_P_S(groupId, parentFolderId, status, start, 1556 end); 1557 } 1558 1559 /** 1560 * Returns an ordered range of all the journal folders that the user has permissions to view where groupId = ? and parentFolderId = ? and status = ?. 1561 * 1562 * <p> 1563 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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. 1564 * </p> 1565 * 1566 * @param groupId the group ID 1567 * @param parentFolderId the parent folder ID 1568 * @param status the status 1569 * @param start the lower bound of the range of journal folders 1570 * @param end the upper bound of the range of journal folders (not inclusive) 1571 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1572 * @return the ordered range of matching journal folders that the user has permission to view 1573 * @throws SystemException if a system exception occurred 1574 */ 1575 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> filterFindByG_P_S( 1576 long groupId, long parentFolderId, int status, int start, int end, 1577 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1578 throws com.liferay.portal.kernel.exception.SystemException { 1579 return getPersistence() 1580 .filterFindByG_P_S(groupId, parentFolderId, status, start, 1581 end, orderByComparator); 1582 } 1583 1584 /** 1585 * 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 = ?. 1586 * 1587 * @param folderId the primary key of the current journal folder 1588 * @param groupId the group ID 1589 * @param parentFolderId the parent folder ID 1590 * @param status the status 1591 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1592 * @return the previous, current, and next journal folder 1593 * @throws com.liferay.portlet.journal.NoSuchFolderException if a journal folder with the primary key could not be found 1594 * @throws SystemException if a system exception occurred 1595 */ 1596 public static com.liferay.portlet.journal.model.JournalFolder[] filterFindByG_P_S_PrevAndNext( 1597 long folderId, long groupId, long parentFolderId, int status, 1598 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1599 throws com.liferay.portal.kernel.exception.SystemException, 1600 com.liferay.portlet.journal.NoSuchFolderException { 1601 return getPersistence() 1602 .filterFindByG_P_S_PrevAndNext(folderId, groupId, 1603 parentFolderId, status, orderByComparator); 1604 } 1605 1606 /** 1607 * Removes all the journal folders where groupId = ? and parentFolderId = ? and status = ? from the database. 1608 * 1609 * @param groupId the group ID 1610 * @param parentFolderId the parent folder ID 1611 * @param status the status 1612 * @throws SystemException if a system exception occurred 1613 */ 1614 public static void removeByG_P_S(long groupId, long parentFolderId, 1615 int status) throws com.liferay.portal.kernel.exception.SystemException { 1616 getPersistence().removeByG_P_S(groupId, parentFolderId, status); 1617 } 1618 1619 /** 1620 * Returns the number of journal folders where groupId = ? and parentFolderId = ? and status = ?. 1621 * 1622 * @param groupId the group ID 1623 * @param parentFolderId the parent folder ID 1624 * @param status the status 1625 * @return the number of matching journal folders 1626 * @throws SystemException if a system exception occurred 1627 */ 1628 public static int countByG_P_S(long groupId, long parentFolderId, int status) 1629 throws com.liferay.portal.kernel.exception.SystemException { 1630 return getPersistence().countByG_P_S(groupId, parentFolderId, status); 1631 } 1632 1633 /** 1634 * Returns the number of journal folders that the user has permission to view where groupId = ? and parentFolderId = ? and status = ?. 1635 * 1636 * @param groupId the group ID 1637 * @param parentFolderId the parent folder ID 1638 * @param status the status 1639 * @return the number of matching journal folders that the user has permission to view 1640 * @throws SystemException if a system exception occurred 1641 */ 1642 public static int filterCountByG_P_S(long groupId, long parentFolderId, 1643 int status) throws com.liferay.portal.kernel.exception.SystemException { 1644 return getPersistence() 1645 .filterCountByG_P_S(groupId, parentFolderId, status); 1646 } 1647 1648 /** 1649 * Returns all the journal folders where groupId = ? and parentFolderId = ? and status ≠ ?. 1650 * 1651 * @param groupId the group ID 1652 * @param parentFolderId the parent folder ID 1653 * @param status the status 1654 * @return the matching journal folders 1655 * @throws SystemException if a system exception occurred 1656 */ 1657 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByG_P_NotS( 1658 long groupId, long parentFolderId, int status) 1659 throws com.liferay.portal.kernel.exception.SystemException { 1660 return getPersistence().findByG_P_NotS(groupId, parentFolderId, status); 1661 } 1662 1663 /** 1664 * Returns a range of all the journal folders where groupId = ? and parentFolderId = ? and status ≠ ?. 1665 * 1666 * <p> 1667 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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. 1668 * </p> 1669 * 1670 * @param groupId the group ID 1671 * @param parentFolderId the parent folder ID 1672 * @param status the status 1673 * @param start the lower bound of the range of journal folders 1674 * @param end the upper bound of the range of journal folders (not inclusive) 1675 * @return the range of matching journal folders 1676 * @throws SystemException if a system exception occurred 1677 */ 1678 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByG_P_NotS( 1679 long groupId, long parentFolderId, int status, int start, int end) 1680 throws com.liferay.portal.kernel.exception.SystemException { 1681 return getPersistence() 1682 .findByG_P_NotS(groupId, parentFolderId, status, start, end); 1683 } 1684 1685 /** 1686 * Returns an ordered range of all the journal folders where groupId = ? and parentFolderId = ? and status ≠ ?. 1687 * 1688 * <p> 1689 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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. 1690 * </p> 1691 * 1692 * @param groupId the group ID 1693 * @param parentFolderId the parent folder ID 1694 * @param status the status 1695 * @param start the lower bound of the range of journal folders 1696 * @param end the upper bound of the range of journal folders (not inclusive) 1697 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1698 * @return the ordered range of matching journal folders 1699 * @throws SystemException if a system exception occurred 1700 */ 1701 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByG_P_NotS( 1702 long groupId, long parentFolderId, int status, int start, int end, 1703 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1704 throws com.liferay.portal.kernel.exception.SystemException { 1705 return getPersistence() 1706 .findByG_P_NotS(groupId, parentFolderId, status, start, end, 1707 orderByComparator); 1708 } 1709 1710 /** 1711 * Returns the first journal folder in the ordered set where groupId = ? and parentFolderId = ? and status ≠ ?. 1712 * 1713 * @param groupId the group ID 1714 * @param parentFolderId the parent folder ID 1715 * @param status the status 1716 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1717 * @return the first matching journal folder 1718 * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found 1719 * @throws SystemException if a system exception occurred 1720 */ 1721 public static com.liferay.portlet.journal.model.JournalFolder findByG_P_NotS_First( 1722 long groupId, long parentFolderId, int status, 1723 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1724 throws com.liferay.portal.kernel.exception.SystemException, 1725 com.liferay.portlet.journal.NoSuchFolderException { 1726 return getPersistence() 1727 .findByG_P_NotS_First(groupId, parentFolderId, status, 1728 orderByComparator); 1729 } 1730 1731 /** 1732 * Returns the first journal folder in the ordered set where groupId = ? and parentFolderId = ? and status ≠ ?. 1733 * 1734 * @param groupId the group ID 1735 * @param parentFolderId the parent folder ID 1736 * @param status the status 1737 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1738 * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found 1739 * @throws SystemException if a system exception occurred 1740 */ 1741 public static com.liferay.portlet.journal.model.JournalFolder fetchByG_P_NotS_First( 1742 long groupId, long parentFolderId, int status, 1743 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1744 throws com.liferay.portal.kernel.exception.SystemException { 1745 return getPersistence() 1746 .fetchByG_P_NotS_First(groupId, parentFolderId, status, 1747 orderByComparator); 1748 } 1749 1750 /** 1751 * Returns the last journal folder in the ordered set where groupId = ? and parentFolderId = ? and status ≠ ?. 1752 * 1753 * @param groupId the group ID 1754 * @param parentFolderId the parent folder ID 1755 * @param status the status 1756 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1757 * @return the last matching journal folder 1758 * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found 1759 * @throws SystemException if a system exception occurred 1760 */ 1761 public static com.liferay.portlet.journal.model.JournalFolder findByG_P_NotS_Last( 1762 long groupId, long parentFolderId, int status, 1763 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1764 throws com.liferay.portal.kernel.exception.SystemException, 1765 com.liferay.portlet.journal.NoSuchFolderException { 1766 return getPersistence() 1767 .findByG_P_NotS_Last(groupId, parentFolderId, status, 1768 orderByComparator); 1769 } 1770 1771 /** 1772 * Returns the last journal folder in the ordered set where groupId = ? and parentFolderId = ? and status ≠ ?. 1773 * 1774 * @param groupId the group ID 1775 * @param parentFolderId the parent folder ID 1776 * @param status the status 1777 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1778 * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found 1779 * @throws SystemException if a system exception occurred 1780 */ 1781 public static com.liferay.portlet.journal.model.JournalFolder fetchByG_P_NotS_Last( 1782 long groupId, long parentFolderId, int status, 1783 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1784 throws com.liferay.portal.kernel.exception.SystemException { 1785 return getPersistence() 1786 .fetchByG_P_NotS_Last(groupId, parentFolderId, status, 1787 orderByComparator); 1788 } 1789 1790 /** 1791 * Returns the journal folders before and after the current journal folder in the ordered set where groupId = ? and parentFolderId = ? and status ≠ ?. 1792 * 1793 * @param folderId the primary key of the current journal folder 1794 * @param groupId the group ID 1795 * @param parentFolderId the parent folder ID 1796 * @param status the status 1797 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1798 * @return the previous, current, and next journal folder 1799 * @throws com.liferay.portlet.journal.NoSuchFolderException if a journal folder with the primary key could not be found 1800 * @throws SystemException if a system exception occurred 1801 */ 1802 public static com.liferay.portlet.journal.model.JournalFolder[] findByG_P_NotS_PrevAndNext( 1803 long folderId, long groupId, long parentFolderId, int status, 1804 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1805 throws com.liferay.portal.kernel.exception.SystemException, 1806 com.liferay.portlet.journal.NoSuchFolderException { 1807 return getPersistence() 1808 .findByG_P_NotS_PrevAndNext(folderId, groupId, 1809 parentFolderId, status, orderByComparator); 1810 } 1811 1812 /** 1813 * Returns all the journal folders that the user has permission to view where groupId = ? and parentFolderId = ? and status ≠ ?. 1814 * 1815 * @param groupId the group ID 1816 * @param parentFolderId the parent folder ID 1817 * @param status the status 1818 * @return the matching journal folders that the user has permission to view 1819 * @throws SystemException if a system exception occurred 1820 */ 1821 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> filterFindByG_P_NotS( 1822 long groupId, long parentFolderId, int status) 1823 throws com.liferay.portal.kernel.exception.SystemException { 1824 return getPersistence() 1825 .filterFindByG_P_NotS(groupId, parentFolderId, status); 1826 } 1827 1828 /** 1829 * Returns a range of all the journal folders that the user has permission to view where groupId = ? and parentFolderId = ? and status ≠ ?. 1830 * 1831 * <p> 1832 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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. 1833 * </p> 1834 * 1835 * @param groupId the group ID 1836 * @param parentFolderId the parent folder ID 1837 * @param status the status 1838 * @param start the lower bound of the range of journal folders 1839 * @param end the upper bound of the range of journal folders (not inclusive) 1840 * @return the range of matching journal folders that the user has permission to view 1841 * @throws SystemException if a system exception occurred 1842 */ 1843 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> filterFindByG_P_NotS( 1844 long groupId, long parentFolderId, int status, int start, int end) 1845 throws com.liferay.portal.kernel.exception.SystemException { 1846 return getPersistence() 1847 .filterFindByG_P_NotS(groupId, parentFolderId, status, 1848 start, end); 1849 } 1850 1851 /** 1852 * Returns an ordered range of all the journal folders that the user has permissions to view where groupId = ? and parentFolderId = ? and status ≠ ?. 1853 * 1854 * <p> 1855 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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. 1856 * </p> 1857 * 1858 * @param groupId the group ID 1859 * @param parentFolderId the parent folder ID 1860 * @param status the status 1861 * @param start the lower bound of the range of journal folders 1862 * @param end the upper bound of the range of journal folders (not inclusive) 1863 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1864 * @return the ordered range of matching journal folders that the user has permission to view 1865 * @throws SystemException if a system exception occurred 1866 */ 1867 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> filterFindByG_P_NotS( 1868 long groupId, long parentFolderId, int status, int start, int end, 1869 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1870 throws com.liferay.portal.kernel.exception.SystemException { 1871 return getPersistence() 1872 .filterFindByG_P_NotS(groupId, parentFolderId, status, 1873 start, end, orderByComparator); 1874 } 1875 1876 /** 1877 * 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 ≠ ?. 1878 * 1879 * @param folderId the primary key of the current journal folder 1880 * @param groupId the group ID 1881 * @param parentFolderId the parent folder ID 1882 * @param status the status 1883 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1884 * @return the previous, current, and next journal folder 1885 * @throws com.liferay.portlet.journal.NoSuchFolderException if a journal folder with the primary key could not be found 1886 * @throws SystemException if a system exception occurred 1887 */ 1888 public static com.liferay.portlet.journal.model.JournalFolder[] filterFindByG_P_NotS_PrevAndNext( 1889 long folderId, long groupId, long parentFolderId, int status, 1890 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1891 throws com.liferay.portal.kernel.exception.SystemException, 1892 com.liferay.portlet.journal.NoSuchFolderException { 1893 return getPersistence() 1894 .filterFindByG_P_NotS_PrevAndNext(folderId, groupId, 1895 parentFolderId, status, orderByComparator); 1896 } 1897 1898 /** 1899 * Removes all the journal folders where groupId = ? and parentFolderId = ? and status ≠ ? from the database. 1900 * 1901 * @param groupId the group ID 1902 * @param parentFolderId the parent folder ID 1903 * @param status the status 1904 * @throws SystemException if a system exception occurred 1905 */ 1906 public static void removeByG_P_NotS(long groupId, long parentFolderId, 1907 int status) throws com.liferay.portal.kernel.exception.SystemException { 1908 getPersistence().removeByG_P_NotS(groupId, parentFolderId, status); 1909 } 1910 1911 /** 1912 * Returns the number of journal folders where groupId = ? and parentFolderId = ? and status ≠ ?. 1913 * 1914 * @param groupId the group ID 1915 * @param parentFolderId the parent folder ID 1916 * @param status the status 1917 * @return the number of matching journal folders 1918 * @throws SystemException if a system exception occurred 1919 */ 1920 public static int countByG_P_NotS(long groupId, long parentFolderId, 1921 int status) throws com.liferay.portal.kernel.exception.SystemException { 1922 return getPersistence().countByG_P_NotS(groupId, parentFolderId, status); 1923 } 1924 1925 /** 1926 * Returns the number of journal folders that the user has permission to view where groupId = ? and parentFolderId = ? and status ≠ ?. 1927 * 1928 * @param groupId the group ID 1929 * @param parentFolderId the parent folder ID 1930 * @param status the status 1931 * @return the number of matching journal folders that the user has permission to view 1932 * @throws SystemException if a system exception occurred 1933 */ 1934 public static int filterCountByG_P_NotS(long groupId, long parentFolderId, 1935 int status) throws com.liferay.portal.kernel.exception.SystemException { 1936 return getPersistence() 1937 .filterCountByG_P_NotS(groupId, parentFolderId, status); 1938 } 1939 1940 /** 1941 * Caches the journal folder in the entity cache if it is enabled. 1942 * 1943 * @param journalFolder the journal folder 1944 */ 1945 public static void cacheResult( 1946 com.liferay.portlet.journal.model.JournalFolder journalFolder) { 1947 getPersistence().cacheResult(journalFolder); 1948 } 1949 1950 /** 1951 * Caches the journal folders in the entity cache if it is enabled. 1952 * 1953 * @param journalFolders the journal folders 1954 */ 1955 public static void cacheResult( 1956 java.util.List<com.liferay.portlet.journal.model.JournalFolder> journalFolders) { 1957 getPersistence().cacheResult(journalFolders); 1958 } 1959 1960 /** 1961 * Creates a new journal folder with the primary key. Does not add the journal folder to the database. 1962 * 1963 * @param folderId the primary key for the new journal folder 1964 * @return the new journal folder 1965 */ 1966 public static com.liferay.portlet.journal.model.JournalFolder create( 1967 long folderId) { 1968 return getPersistence().create(folderId); 1969 } 1970 1971 /** 1972 * Removes the journal folder with the primary key from the database. Also notifies the appropriate model listeners. 1973 * 1974 * @param folderId the primary key of the journal folder 1975 * @return the journal folder that was removed 1976 * @throws com.liferay.portlet.journal.NoSuchFolderException if a journal folder with the primary key could not be found 1977 * @throws SystemException if a system exception occurred 1978 */ 1979 public static com.liferay.portlet.journal.model.JournalFolder remove( 1980 long folderId) 1981 throws com.liferay.portal.kernel.exception.SystemException, 1982 com.liferay.portlet.journal.NoSuchFolderException { 1983 return getPersistence().remove(folderId); 1984 } 1985 1986 public static com.liferay.portlet.journal.model.JournalFolder updateImpl( 1987 com.liferay.portlet.journal.model.JournalFolder journalFolder) 1988 throws com.liferay.portal.kernel.exception.SystemException { 1989 return getPersistence().updateImpl(journalFolder); 1990 } 1991 1992 /** 1993 * Returns the journal folder with the primary key or throws a {@link com.liferay.portlet.journal.NoSuchFolderException} if it could not be found. 1994 * 1995 * @param folderId the primary key of the journal folder 1996 * @return the journal folder 1997 * @throws com.liferay.portlet.journal.NoSuchFolderException if a journal folder with the primary key could not be found 1998 * @throws SystemException if a system exception occurred 1999 */ 2000 public static com.liferay.portlet.journal.model.JournalFolder findByPrimaryKey( 2001 long folderId) 2002 throws com.liferay.portal.kernel.exception.SystemException, 2003 com.liferay.portlet.journal.NoSuchFolderException { 2004 return getPersistence().findByPrimaryKey(folderId); 2005 } 2006 2007 /** 2008 * Returns the journal folder with the primary key or returns <code>null</code> if it could not be found. 2009 * 2010 * @param folderId the primary key of the journal folder 2011 * @return the journal folder, or <code>null</code> if a journal folder with the primary key could not be found 2012 * @throws SystemException if a system exception occurred 2013 */ 2014 public static com.liferay.portlet.journal.model.JournalFolder fetchByPrimaryKey( 2015 long folderId) 2016 throws com.liferay.portal.kernel.exception.SystemException { 2017 return getPersistence().fetchByPrimaryKey(folderId); 2018 } 2019 2020 /** 2021 * Returns all the journal folders. 2022 * 2023 * @return the journal folders 2024 * @throws SystemException if a system exception occurred 2025 */ 2026 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findAll() 2027 throws com.liferay.portal.kernel.exception.SystemException { 2028 return getPersistence().findAll(); 2029 } 2030 2031 /** 2032 * Returns a range of all the journal folders. 2033 * 2034 * <p> 2035 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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. 2036 * </p> 2037 * 2038 * @param start the lower bound of the range of journal folders 2039 * @param end the upper bound of the range of journal folders (not inclusive) 2040 * @return the range of journal folders 2041 * @throws SystemException if a system exception occurred 2042 */ 2043 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findAll( 2044 int start, int end) 2045 throws com.liferay.portal.kernel.exception.SystemException { 2046 return getPersistence().findAll(start, end); 2047 } 2048 2049 /** 2050 * Returns an ordered range of all the journal folders. 2051 * 2052 * <p> 2053 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.journal.model.impl.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. 2054 * </p> 2055 * 2056 * @param start the lower bound of the range of journal folders 2057 * @param end the upper bound of the range of journal folders (not inclusive) 2058 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2059 * @return the ordered range of journal folders 2060 * @throws SystemException if a system exception occurred 2061 */ 2062 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findAll( 2063 int start, int end, 2064 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2065 throws com.liferay.portal.kernel.exception.SystemException { 2066 return getPersistence().findAll(start, end, orderByComparator); 2067 } 2068 2069 /** 2070 * Removes all the journal folders from the database. 2071 * 2072 * @throws SystemException if a system exception occurred 2073 */ 2074 public static void removeAll() 2075 throws com.liferay.portal.kernel.exception.SystemException { 2076 getPersistence().removeAll(); 2077 } 2078 2079 /** 2080 * Returns the number of journal folders. 2081 * 2082 * @return the number of journal folders 2083 * @throws SystemException if a system exception occurred 2084 */ 2085 public static int countAll() 2086 throws com.liferay.portal.kernel.exception.SystemException { 2087 return getPersistence().countAll(); 2088 } 2089 2090 public static JournalFolderPersistence getPersistence() { 2091 if (_persistence == null) { 2092 _persistence = (JournalFolderPersistence)PortalBeanLocatorUtil.locate(JournalFolderPersistence.class.getName()); 2093 2094 ReferenceRegistry.registerReference(JournalFolderUtil.class, 2095 "_persistence"); 2096 } 2097 2098 return _persistence; 2099 } 2100 2101 /** 2102 * @deprecated As of 6.2.0 2103 */ 2104 public void setPersistence(JournalFolderPersistence persistence) { 2105 } 2106 2107 private static JournalFolderPersistence _persistence; 2108 }