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 static 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 all the journal folders where companyId = ? and status ≠ ?. 1276 * 1277 * @param companyId the company ID 1278 * @param status the status 1279 * @return the matching journal folders 1280 * @throws SystemException if a system exception occurred 1281 */ 1282 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByC_NotS( 1283 long companyId, int status) 1284 throws com.liferay.portal.kernel.exception.SystemException { 1285 return getPersistence().findByC_NotS(companyId, status); 1286 } 1287 1288 /** 1289 * Returns a range of all the journal folders where companyId = ? and status ≠ ?. 1290 * 1291 * <p> 1292 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1293 * </p> 1294 * 1295 * @param companyId the company ID 1296 * @param status the status 1297 * @param start the lower bound of the range of journal folders 1298 * @param end the upper bound of the range of journal folders (not inclusive) 1299 * @return the range of matching journal folders 1300 * @throws SystemException if a system exception occurred 1301 */ 1302 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByC_NotS( 1303 long companyId, int status, int start, int end) 1304 throws com.liferay.portal.kernel.exception.SystemException { 1305 return getPersistence().findByC_NotS(companyId, status, start, end); 1306 } 1307 1308 /** 1309 * Returns an ordered range of all the journal folders where companyId = ? and status ≠ ?. 1310 * 1311 * <p> 1312 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1313 * </p> 1314 * 1315 * @param companyId the company ID 1316 * @param status the status 1317 * @param start the lower bound of the range of journal folders 1318 * @param end the upper bound of the range of journal folders (not inclusive) 1319 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1320 * @return the ordered range of matching journal folders 1321 * @throws SystemException if a system exception occurred 1322 */ 1323 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByC_NotS( 1324 long companyId, int status, int start, int end, 1325 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1326 throws com.liferay.portal.kernel.exception.SystemException { 1327 return getPersistence() 1328 .findByC_NotS(companyId, status, start, end, 1329 orderByComparator); 1330 } 1331 1332 /** 1333 * Returns the first journal folder in the ordered set where companyId = ? and status ≠ ?. 1334 * 1335 * @param companyId the company ID 1336 * @param status the status 1337 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1338 * @return the first matching journal folder 1339 * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found 1340 * @throws SystemException if a system exception occurred 1341 */ 1342 public static com.liferay.portlet.journal.model.JournalFolder findByC_NotS_First( 1343 long companyId, int status, 1344 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1345 throws com.liferay.portal.kernel.exception.SystemException, 1346 com.liferay.portlet.journal.NoSuchFolderException { 1347 return getPersistence() 1348 .findByC_NotS_First(companyId, status, orderByComparator); 1349 } 1350 1351 /** 1352 * Returns the first journal folder in the ordered set where companyId = ? and status ≠ ?. 1353 * 1354 * @param companyId the company ID 1355 * @param status the status 1356 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1357 * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found 1358 * @throws SystemException if a system exception occurred 1359 */ 1360 public static com.liferay.portlet.journal.model.JournalFolder fetchByC_NotS_First( 1361 long companyId, int status, 1362 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1363 throws com.liferay.portal.kernel.exception.SystemException { 1364 return getPersistence() 1365 .fetchByC_NotS_First(companyId, status, orderByComparator); 1366 } 1367 1368 /** 1369 * Returns the last journal folder in the ordered set where companyId = ? and status ≠ ?. 1370 * 1371 * @param companyId the company ID 1372 * @param status the status 1373 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1374 * @return the last matching journal folder 1375 * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found 1376 * @throws SystemException if a system exception occurred 1377 */ 1378 public static com.liferay.portlet.journal.model.JournalFolder findByC_NotS_Last( 1379 long companyId, int status, 1380 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1381 throws com.liferay.portal.kernel.exception.SystemException, 1382 com.liferay.portlet.journal.NoSuchFolderException { 1383 return getPersistence() 1384 .findByC_NotS_Last(companyId, status, orderByComparator); 1385 } 1386 1387 /** 1388 * Returns the last journal folder in the ordered set where companyId = ? and status ≠ ?. 1389 * 1390 * @param companyId the company ID 1391 * @param status the status 1392 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1393 * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found 1394 * @throws SystemException if a system exception occurred 1395 */ 1396 public static com.liferay.portlet.journal.model.JournalFolder fetchByC_NotS_Last( 1397 long companyId, int status, 1398 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1399 throws com.liferay.portal.kernel.exception.SystemException { 1400 return getPersistence() 1401 .fetchByC_NotS_Last(companyId, status, orderByComparator); 1402 } 1403 1404 /** 1405 * Returns the journal folders before and after the current journal folder in the ordered set where companyId = ? and status ≠ ?. 1406 * 1407 * @param folderId the primary key of the current journal folder 1408 * @param companyId the company ID 1409 * @param status the status 1410 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1411 * @return the previous, current, and next journal folder 1412 * @throws com.liferay.portlet.journal.NoSuchFolderException if a journal folder with the primary key could not be found 1413 * @throws SystemException if a system exception occurred 1414 */ 1415 public static com.liferay.portlet.journal.model.JournalFolder[] findByC_NotS_PrevAndNext( 1416 long folderId, long companyId, int status, 1417 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1418 throws com.liferay.portal.kernel.exception.SystemException, 1419 com.liferay.portlet.journal.NoSuchFolderException { 1420 return getPersistence() 1421 .findByC_NotS_PrevAndNext(folderId, companyId, status, 1422 orderByComparator); 1423 } 1424 1425 /** 1426 * Removes all the journal folders where companyId = ? and status ≠ ? from the database. 1427 * 1428 * @param companyId the company ID 1429 * @param status the status 1430 * @throws SystemException if a system exception occurred 1431 */ 1432 public static void removeByC_NotS(long companyId, int status) 1433 throws com.liferay.portal.kernel.exception.SystemException { 1434 getPersistence().removeByC_NotS(companyId, status); 1435 } 1436 1437 /** 1438 * Returns the number of journal folders where companyId = ? and status ≠ ?. 1439 * 1440 * @param companyId the company ID 1441 * @param status the status 1442 * @return the number of matching journal folders 1443 * @throws SystemException if a system exception occurred 1444 */ 1445 public static int countByC_NotS(long companyId, int status) 1446 throws com.liferay.portal.kernel.exception.SystemException { 1447 return getPersistence().countByC_NotS(companyId, status); 1448 } 1449 1450 /** 1451 * 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. 1452 * 1453 * @param groupId the group ID 1454 * @param parentFolderId the parent folder ID 1455 * @param name the name 1456 * @return the matching journal folder 1457 * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found 1458 * @throws SystemException if a system exception occurred 1459 */ 1460 public static com.liferay.portlet.journal.model.JournalFolder findByG_P_N( 1461 long groupId, long parentFolderId, java.lang.String name) 1462 throws com.liferay.portal.kernel.exception.SystemException, 1463 com.liferay.portlet.journal.NoSuchFolderException { 1464 return getPersistence().findByG_P_N(groupId, parentFolderId, name); 1465 } 1466 1467 /** 1468 * 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. 1469 * 1470 * @param groupId the group ID 1471 * @param parentFolderId the parent folder ID 1472 * @param name the name 1473 * @return the matching journal folder, or <code>null</code> if a matching journal folder could not be found 1474 * @throws SystemException if a system exception occurred 1475 */ 1476 public static com.liferay.portlet.journal.model.JournalFolder fetchByG_P_N( 1477 long groupId, long parentFolderId, java.lang.String name) 1478 throws com.liferay.portal.kernel.exception.SystemException { 1479 return getPersistence().fetchByG_P_N(groupId, parentFolderId, name); 1480 } 1481 1482 /** 1483 * 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. 1484 * 1485 * @param groupId the group ID 1486 * @param parentFolderId the parent folder ID 1487 * @param name the name 1488 * @param retrieveFromCache whether to use the finder cache 1489 * @return the matching journal folder, or <code>null</code> if a matching journal folder could not be found 1490 * @throws SystemException if a system exception occurred 1491 */ 1492 public static com.liferay.portlet.journal.model.JournalFolder fetchByG_P_N( 1493 long groupId, long parentFolderId, java.lang.String name, 1494 boolean retrieveFromCache) 1495 throws com.liferay.portal.kernel.exception.SystemException { 1496 return getPersistence() 1497 .fetchByG_P_N(groupId, parentFolderId, name, 1498 retrieveFromCache); 1499 } 1500 1501 /** 1502 * Removes the journal folder where groupId = ? and parentFolderId = ? and name = ? from the database. 1503 * 1504 * @param groupId the group ID 1505 * @param parentFolderId the parent folder ID 1506 * @param name the name 1507 * @return the journal folder that was removed 1508 * @throws SystemException if a system exception occurred 1509 */ 1510 public static com.liferay.portlet.journal.model.JournalFolder removeByG_P_N( 1511 long groupId, long parentFolderId, java.lang.String name) 1512 throws com.liferay.portal.kernel.exception.SystemException, 1513 com.liferay.portlet.journal.NoSuchFolderException { 1514 return getPersistence().removeByG_P_N(groupId, parentFolderId, name); 1515 } 1516 1517 /** 1518 * Returns the number of journal folders where groupId = ? and parentFolderId = ? and name = ?. 1519 * 1520 * @param groupId the group ID 1521 * @param parentFolderId the parent folder ID 1522 * @param name the name 1523 * @return the number of matching journal folders 1524 * @throws SystemException if a system exception occurred 1525 */ 1526 public static int countByG_P_N(long groupId, long parentFolderId, 1527 java.lang.String name) 1528 throws com.liferay.portal.kernel.exception.SystemException { 1529 return getPersistence().countByG_P_N(groupId, parentFolderId, name); 1530 } 1531 1532 /** 1533 * Returns all the journal folders where groupId = ? and parentFolderId = ? and status = ?. 1534 * 1535 * @param groupId the group ID 1536 * @param parentFolderId the parent folder ID 1537 * @param status the status 1538 * @return the matching journal folders 1539 * @throws SystemException if a system exception occurred 1540 */ 1541 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByG_P_S( 1542 long groupId, long parentFolderId, int status) 1543 throws com.liferay.portal.kernel.exception.SystemException { 1544 return getPersistence().findByG_P_S(groupId, parentFolderId, status); 1545 } 1546 1547 /** 1548 * Returns a range of all the journal folders where groupId = ? and parentFolderId = ? and status = ?. 1549 * 1550 * <p> 1551 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1552 * </p> 1553 * 1554 * @param groupId the group ID 1555 * @param parentFolderId the parent folder ID 1556 * @param status the status 1557 * @param start the lower bound of the range of journal folders 1558 * @param end the upper bound of the range of journal folders (not inclusive) 1559 * @return the range of matching journal folders 1560 * @throws SystemException if a system exception occurred 1561 */ 1562 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByG_P_S( 1563 long groupId, long parentFolderId, int status, int start, int end) 1564 throws com.liferay.portal.kernel.exception.SystemException { 1565 return getPersistence() 1566 .findByG_P_S(groupId, parentFolderId, status, start, end); 1567 } 1568 1569 /** 1570 * Returns an ordered range of all the journal folders where groupId = ? and parentFolderId = ? and status = ?. 1571 * 1572 * <p> 1573 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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. 1574 * </p> 1575 * 1576 * @param groupId the group ID 1577 * @param parentFolderId the parent folder ID 1578 * @param status the status 1579 * @param start the lower bound of the range of journal folders 1580 * @param end the upper bound of the range of journal folders (not inclusive) 1581 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1582 * @return the ordered range of matching journal folders 1583 * @throws SystemException if a system exception occurred 1584 */ 1585 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByG_P_S( 1586 long groupId, long parentFolderId, int status, int start, int end, 1587 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1588 throws com.liferay.portal.kernel.exception.SystemException { 1589 return getPersistence() 1590 .findByG_P_S(groupId, parentFolderId, status, start, end, 1591 orderByComparator); 1592 } 1593 1594 /** 1595 * Returns the first journal folder in the ordered set where groupId = ? and parentFolderId = ? and status = ?. 1596 * 1597 * @param groupId the group ID 1598 * @param parentFolderId the parent folder ID 1599 * @param status the status 1600 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1601 * @return the first matching journal folder 1602 * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found 1603 * @throws SystemException if a system exception occurred 1604 */ 1605 public static com.liferay.portlet.journal.model.JournalFolder findByG_P_S_First( 1606 long groupId, long parentFolderId, int status, 1607 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1608 throws com.liferay.portal.kernel.exception.SystemException, 1609 com.liferay.portlet.journal.NoSuchFolderException { 1610 return getPersistence() 1611 .findByG_P_S_First(groupId, parentFolderId, status, 1612 orderByComparator); 1613 } 1614 1615 /** 1616 * Returns the first journal folder in the ordered set where groupId = ? and parentFolderId = ? and status = ?. 1617 * 1618 * @param groupId the group ID 1619 * @param parentFolderId the parent folder ID 1620 * @param status the status 1621 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1622 * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found 1623 * @throws SystemException if a system exception occurred 1624 */ 1625 public static com.liferay.portlet.journal.model.JournalFolder fetchByG_P_S_First( 1626 long groupId, long parentFolderId, int status, 1627 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1628 throws com.liferay.portal.kernel.exception.SystemException { 1629 return getPersistence() 1630 .fetchByG_P_S_First(groupId, parentFolderId, status, 1631 orderByComparator); 1632 } 1633 1634 /** 1635 * Returns the last journal folder in the ordered set where groupId = ? and parentFolderId = ? and status = ?. 1636 * 1637 * @param groupId the group ID 1638 * @param parentFolderId the parent folder ID 1639 * @param status the status 1640 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1641 * @return the last matching journal folder 1642 * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found 1643 * @throws SystemException if a system exception occurred 1644 */ 1645 public static com.liferay.portlet.journal.model.JournalFolder findByG_P_S_Last( 1646 long groupId, long parentFolderId, int status, 1647 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1648 throws com.liferay.portal.kernel.exception.SystemException, 1649 com.liferay.portlet.journal.NoSuchFolderException { 1650 return getPersistence() 1651 .findByG_P_S_Last(groupId, parentFolderId, status, 1652 orderByComparator); 1653 } 1654 1655 /** 1656 * Returns the last journal folder in the ordered set where groupId = ? and parentFolderId = ? and status = ?. 1657 * 1658 * @param groupId the group ID 1659 * @param parentFolderId the parent folder ID 1660 * @param status the status 1661 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1662 * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found 1663 * @throws SystemException if a system exception occurred 1664 */ 1665 public static com.liferay.portlet.journal.model.JournalFolder fetchByG_P_S_Last( 1666 long groupId, long parentFolderId, int status, 1667 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1668 throws com.liferay.portal.kernel.exception.SystemException { 1669 return getPersistence() 1670 .fetchByG_P_S_Last(groupId, parentFolderId, status, 1671 orderByComparator); 1672 } 1673 1674 /** 1675 * Returns the journal folders before and after the current journal folder in the ordered set where groupId = ? and parentFolderId = ? and status = ?. 1676 * 1677 * @param folderId the primary key of the current journal folder 1678 * @param groupId the group ID 1679 * @param parentFolderId the parent folder ID 1680 * @param status the status 1681 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1682 * @return the previous, current, and next journal folder 1683 * @throws com.liferay.portlet.journal.NoSuchFolderException if a journal folder with the primary key could not be found 1684 * @throws SystemException if a system exception occurred 1685 */ 1686 public static com.liferay.portlet.journal.model.JournalFolder[] findByG_P_S_PrevAndNext( 1687 long folderId, long groupId, long parentFolderId, int status, 1688 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1689 throws com.liferay.portal.kernel.exception.SystemException, 1690 com.liferay.portlet.journal.NoSuchFolderException { 1691 return getPersistence() 1692 .findByG_P_S_PrevAndNext(folderId, groupId, parentFolderId, 1693 status, orderByComparator); 1694 } 1695 1696 /** 1697 * Returns all the journal folders that the user has permission to view where groupId = ? and parentFolderId = ? and status = ?. 1698 * 1699 * @param groupId the group ID 1700 * @param parentFolderId the parent folder ID 1701 * @param status the status 1702 * @return the matching journal folders that the user has permission to view 1703 * @throws SystemException if a system exception occurred 1704 */ 1705 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> filterFindByG_P_S( 1706 long groupId, long parentFolderId, int status) 1707 throws com.liferay.portal.kernel.exception.SystemException { 1708 return getPersistence() 1709 .filterFindByG_P_S(groupId, parentFolderId, status); 1710 } 1711 1712 /** 1713 * Returns a range of all the journal folders that the user has permission to view where groupId = ? and parentFolderId = ? and status = ?. 1714 * 1715 * <p> 1716 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1717 * </p> 1718 * 1719 * @param groupId the group ID 1720 * @param parentFolderId the parent folder ID 1721 * @param status the status 1722 * @param start the lower bound of the range of journal folders 1723 * @param end the upper bound of the range of journal folders (not inclusive) 1724 * @return the range of matching journal folders that the user has permission to view 1725 * @throws SystemException if a system exception occurred 1726 */ 1727 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> filterFindByG_P_S( 1728 long groupId, long parentFolderId, int status, int start, int end) 1729 throws com.liferay.portal.kernel.exception.SystemException { 1730 return getPersistence() 1731 .filterFindByG_P_S(groupId, parentFolderId, status, start, 1732 end); 1733 } 1734 1735 /** 1736 * Returns an ordered range of all the journal folders that the user has permissions to view where groupId = ? and parentFolderId = ? and status = ?. 1737 * 1738 * <p> 1739 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1740 * </p> 1741 * 1742 * @param groupId the group ID 1743 * @param parentFolderId the parent folder ID 1744 * @param status the status 1745 * @param start the lower bound of the range of journal folders 1746 * @param end the upper bound of the range of journal folders (not inclusive) 1747 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1748 * @return the ordered range of matching journal folders that the user has permission to view 1749 * @throws SystemException if a system exception occurred 1750 */ 1751 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> filterFindByG_P_S( 1752 long groupId, long parentFolderId, int status, int start, int end, 1753 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1754 throws com.liferay.portal.kernel.exception.SystemException { 1755 return getPersistence() 1756 .filterFindByG_P_S(groupId, parentFolderId, status, start, 1757 end, orderByComparator); 1758 } 1759 1760 /** 1761 * 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 = ?. 1762 * 1763 * @param folderId the primary key of the current journal folder 1764 * @param groupId the group ID 1765 * @param parentFolderId the parent folder ID 1766 * @param status the status 1767 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1768 * @return the previous, current, and next journal folder 1769 * @throws com.liferay.portlet.journal.NoSuchFolderException if a journal folder with the primary key could not be found 1770 * @throws SystemException if a system exception occurred 1771 */ 1772 public static com.liferay.portlet.journal.model.JournalFolder[] filterFindByG_P_S_PrevAndNext( 1773 long folderId, long groupId, long parentFolderId, int status, 1774 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1775 throws com.liferay.portal.kernel.exception.SystemException, 1776 com.liferay.portlet.journal.NoSuchFolderException { 1777 return getPersistence() 1778 .filterFindByG_P_S_PrevAndNext(folderId, groupId, 1779 parentFolderId, status, orderByComparator); 1780 } 1781 1782 /** 1783 * Removes all the journal folders where groupId = ? and parentFolderId = ? and status = ? from the database. 1784 * 1785 * @param groupId the group ID 1786 * @param parentFolderId the parent folder ID 1787 * @param status the status 1788 * @throws SystemException if a system exception occurred 1789 */ 1790 public static void removeByG_P_S(long groupId, long parentFolderId, 1791 int status) throws com.liferay.portal.kernel.exception.SystemException { 1792 getPersistence().removeByG_P_S(groupId, parentFolderId, status); 1793 } 1794 1795 /** 1796 * Returns the number of journal folders where groupId = ? and parentFolderId = ? and status = ?. 1797 * 1798 * @param groupId the group ID 1799 * @param parentFolderId the parent folder ID 1800 * @param status the status 1801 * @return the number of matching journal folders 1802 * @throws SystemException if a system exception occurred 1803 */ 1804 public static int countByG_P_S(long groupId, long parentFolderId, int status) 1805 throws com.liferay.portal.kernel.exception.SystemException { 1806 return getPersistence().countByG_P_S(groupId, parentFolderId, status); 1807 } 1808 1809 /** 1810 * Returns the number of journal folders that the user has permission to view where groupId = ? and parentFolderId = ? and status = ?. 1811 * 1812 * @param groupId the group ID 1813 * @param parentFolderId the parent folder ID 1814 * @param status the status 1815 * @return the number of matching journal folders that the user has permission to view 1816 * @throws SystemException if a system exception occurred 1817 */ 1818 public static int filterCountByG_P_S(long groupId, long parentFolderId, 1819 int status) throws com.liferay.portal.kernel.exception.SystemException { 1820 return getPersistence() 1821 .filterCountByG_P_S(groupId, parentFolderId, status); 1822 } 1823 1824 /** 1825 * Returns all the journal folders where groupId = ? and parentFolderId = ? and status ≠ ?. 1826 * 1827 * @param groupId the group ID 1828 * @param parentFolderId the parent folder ID 1829 * @param status the status 1830 * @return the matching journal folders 1831 * @throws SystemException if a system exception occurred 1832 */ 1833 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByG_P_NotS( 1834 long groupId, long parentFolderId, int status) 1835 throws com.liferay.portal.kernel.exception.SystemException { 1836 return getPersistence().findByG_P_NotS(groupId, parentFolderId, status); 1837 } 1838 1839 /** 1840 * Returns a range of all the journal folders where groupId = ? and parentFolderId = ? and status ≠ ?. 1841 * 1842 * <p> 1843 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1844 * </p> 1845 * 1846 * @param groupId the group ID 1847 * @param parentFolderId the parent folder ID 1848 * @param status the status 1849 * @param start the lower bound of the range of journal folders 1850 * @param end the upper bound of the range of journal folders (not inclusive) 1851 * @return the range of matching journal folders 1852 * @throws SystemException if a system exception occurred 1853 */ 1854 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByG_P_NotS( 1855 long groupId, long parentFolderId, int status, int start, int end) 1856 throws com.liferay.portal.kernel.exception.SystemException { 1857 return getPersistence() 1858 .findByG_P_NotS(groupId, parentFolderId, status, start, end); 1859 } 1860 1861 /** 1862 * Returns an ordered range of all the journal folders where groupId = ? and parentFolderId = ? and status ≠ ?. 1863 * 1864 * <p> 1865 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1866 * </p> 1867 * 1868 * @param groupId the group ID 1869 * @param parentFolderId the parent folder ID 1870 * @param status the status 1871 * @param start the lower bound of the range of journal folders 1872 * @param end the upper bound of the range of journal folders (not inclusive) 1873 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1874 * @return the ordered range of matching journal folders 1875 * @throws SystemException if a system exception occurred 1876 */ 1877 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findByG_P_NotS( 1878 long groupId, long parentFolderId, int status, int start, int end, 1879 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1880 throws com.liferay.portal.kernel.exception.SystemException { 1881 return getPersistence() 1882 .findByG_P_NotS(groupId, parentFolderId, status, start, end, 1883 orderByComparator); 1884 } 1885 1886 /** 1887 * Returns the first journal folder in the ordered set where groupId = ? and parentFolderId = ? and status ≠ ?. 1888 * 1889 * @param groupId the group ID 1890 * @param parentFolderId the parent folder ID 1891 * @param status the status 1892 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1893 * @return the first matching journal folder 1894 * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found 1895 * @throws SystemException if a system exception occurred 1896 */ 1897 public static com.liferay.portlet.journal.model.JournalFolder findByG_P_NotS_First( 1898 long groupId, long parentFolderId, int status, 1899 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1900 throws com.liferay.portal.kernel.exception.SystemException, 1901 com.liferay.portlet.journal.NoSuchFolderException { 1902 return getPersistence() 1903 .findByG_P_NotS_First(groupId, parentFolderId, status, 1904 orderByComparator); 1905 } 1906 1907 /** 1908 * Returns the first journal folder in the ordered set where groupId = ? and parentFolderId = ? and status ≠ ?. 1909 * 1910 * @param groupId the group ID 1911 * @param parentFolderId the parent folder ID 1912 * @param status the status 1913 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1914 * @return the first matching journal folder, or <code>null</code> if a matching journal folder could not be found 1915 * @throws SystemException if a system exception occurred 1916 */ 1917 public static com.liferay.portlet.journal.model.JournalFolder fetchByG_P_NotS_First( 1918 long groupId, long parentFolderId, int status, 1919 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1920 throws com.liferay.portal.kernel.exception.SystemException { 1921 return getPersistence() 1922 .fetchByG_P_NotS_First(groupId, parentFolderId, status, 1923 orderByComparator); 1924 } 1925 1926 /** 1927 * Returns the last journal folder in the ordered set where groupId = ? and parentFolderId = ? and status ≠ ?. 1928 * 1929 * @param groupId the group ID 1930 * @param parentFolderId the parent folder ID 1931 * @param status the status 1932 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1933 * @return the last matching journal folder 1934 * @throws com.liferay.portlet.journal.NoSuchFolderException if a matching journal folder could not be found 1935 * @throws SystemException if a system exception occurred 1936 */ 1937 public static com.liferay.portlet.journal.model.JournalFolder findByG_P_NotS_Last( 1938 long groupId, long parentFolderId, int status, 1939 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1940 throws com.liferay.portal.kernel.exception.SystemException, 1941 com.liferay.portlet.journal.NoSuchFolderException { 1942 return getPersistence() 1943 .findByG_P_NotS_Last(groupId, parentFolderId, status, 1944 orderByComparator); 1945 } 1946 1947 /** 1948 * Returns the last journal folder in the ordered set where groupId = ? and parentFolderId = ? and status ≠ ?. 1949 * 1950 * @param groupId the group ID 1951 * @param parentFolderId the parent folder ID 1952 * @param status the status 1953 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1954 * @return the last matching journal folder, or <code>null</code> if a matching journal folder could not be found 1955 * @throws SystemException if a system exception occurred 1956 */ 1957 public static com.liferay.portlet.journal.model.JournalFolder fetchByG_P_NotS_Last( 1958 long groupId, long parentFolderId, int status, 1959 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1960 throws com.liferay.portal.kernel.exception.SystemException { 1961 return getPersistence() 1962 .fetchByG_P_NotS_Last(groupId, parentFolderId, status, 1963 orderByComparator); 1964 } 1965 1966 /** 1967 * Returns the journal folders before and after the current journal folder in the ordered set where groupId = ? and parentFolderId = ? and status ≠ ?. 1968 * 1969 * @param folderId the primary key of the current journal folder 1970 * @param groupId the group ID 1971 * @param parentFolderId the parent folder ID 1972 * @param status the status 1973 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1974 * @return the previous, current, and next journal folder 1975 * @throws com.liferay.portlet.journal.NoSuchFolderException if a journal folder with the primary key could not be found 1976 * @throws SystemException if a system exception occurred 1977 */ 1978 public static com.liferay.portlet.journal.model.JournalFolder[] findByG_P_NotS_PrevAndNext( 1979 long folderId, long groupId, long parentFolderId, int status, 1980 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1981 throws com.liferay.portal.kernel.exception.SystemException, 1982 com.liferay.portlet.journal.NoSuchFolderException { 1983 return getPersistence() 1984 .findByG_P_NotS_PrevAndNext(folderId, groupId, 1985 parentFolderId, status, orderByComparator); 1986 } 1987 1988 /** 1989 * Returns all the journal folders that the user has permission to view where groupId = ? and parentFolderId = ? and status ≠ ?. 1990 * 1991 * @param groupId the group ID 1992 * @param parentFolderId the parent folder ID 1993 * @param status the status 1994 * @return the matching journal folders that the user has permission to view 1995 * @throws SystemException if a system exception occurred 1996 */ 1997 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> filterFindByG_P_NotS( 1998 long groupId, long parentFolderId, int status) 1999 throws com.liferay.portal.kernel.exception.SystemException { 2000 return getPersistence() 2001 .filterFindByG_P_NotS(groupId, parentFolderId, status); 2002 } 2003 2004 /** 2005 * Returns a range of all the journal folders that the user has permission to view where groupId = ? and parentFolderId = ? and status ≠ ?. 2006 * 2007 * <p> 2008 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2009 * </p> 2010 * 2011 * @param groupId the group ID 2012 * @param parentFolderId the parent folder ID 2013 * @param status the status 2014 * @param start the lower bound of the range of journal folders 2015 * @param end the upper bound of the range of journal folders (not inclusive) 2016 * @return the range of matching journal folders that the user has permission to view 2017 * @throws SystemException if a system exception occurred 2018 */ 2019 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> filterFindByG_P_NotS( 2020 long groupId, long parentFolderId, int status, int start, int end) 2021 throws com.liferay.portal.kernel.exception.SystemException { 2022 return getPersistence() 2023 .filterFindByG_P_NotS(groupId, parentFolderId, status, 2024 start, end); 2025 } 2026 2027 /** 2028 * Returns an ordered range of all the journal folders that the user has permissions to view where groupId = ? and parentFolderId = ? and status ≠ ?. 2029 * 2030 * <p> 2031 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2032 * </p> 2033 * 2034 * @param groupId the group ID 2035 * @param parentFolderId the parent folder ID 2036 * @param status the status 2037 * @param start the lower bound of the range of journal folders 2038 * @param end the upper bound of the range of journal folders (not inclusive) 2039 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2040 * @return the ordered range of matching journal folders that the user has permission to view 2041 * @throws SystemException if a system exception occurred 2042 */ 2043 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> filterFindByG_P_NotS( 2044 long groupId, long parentFolderId, int status, int start, int end, 2045 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2046 throws com.liferay.portal.kernel.exception.SystemException { 2047 return getPersistence() 2048 .filterFindByG_P_NotS(groupId, parentFolderId, status, 2049 start, end, orderByComparator); 2050 } 2051 2052 /** 2053 * 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 ≠ ?. 2054 * 2055 * @param folderId the primary key of the current journal folder 2056 * @param groupId the group ID 2057 * @param parentFolderId the parent folder ID 2058 * @param status the status 2059 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2060 * @return the previous, current, and next journal folder 2061 * @throws com.liferay.portlet.journal.NoSuchFolderException if a journal folder with the primary key could not be found 2062 * @throws SystemException if a system exception occurred 2063 */ 2064 public static com.liferay.portlet.journal.model.JournalFolder[] filterFindByG_P_NotS_PrevAndNext( 2065 long folderId, long groupId, long parentFolderId, int status, 2066 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2067 throws com.liferay.portal.kernel.exception.SystemException, 2068 com.liferay.portlet.journal.NoSuchFolderException { 2069 return getPersistence() 2070 .filterFindByG_P_NotS_PrevAndNext(folderId, groupId, 2071 parentFolderId, status, orderByComparator); 2072 } 2073 2074 /** 2075 * Removes all the journal folders where groupId = ? and parentFolderId = ? and status ≠ ? from the database. 2076 * 2077 * @param groupId the group ID 2078 * @param parentFolderId the parent folder ID 2079 * @param status the status 2080 * @throws SystemException if a system exception occurred 2081 */ 2082 public static void removeByG_P_NotS(long groupId, long parentFolderId, 2083 int status) throws com.liferay.portal.kernel.exception.SystemException { 2084 getPersistence().removeByG_P_NotS(groupId, parentFolderId, status); 2085 } 2086 2087 /** 2088 * Returns the number of journal folders where groupId = ? and parentFolderId = ? and status ≠ ?. 2089 * 2090 * @param groupId the group ID 2091 * @param parentFolderId the parent folder ID 2092 * @param status the status 2093 * @return the number of matching journal folders 2094 * @throws SystemException if a system exception occurred 2095 */ 2096 public static int countByG_P_NotS(long groupId, long parentFolderId, 2097 int status) throws com.liferay.portal.kernel.exception.SystemException { 2098 return getPersistence().countByG_P_NotS(groupId, parentFolderId, status); 2099 } 2100 2101 /** 2102 * Returns the number of journal folders that the user has permission to view where groupId = ? and parentFolderId = ? and status ≠ ?. 2103 * 2104 * @param groupId the group ID 2105 * @param parentFolderId the parent folder ID 2106 * @param status the status 2107 * @return the number of matching journal folders that the user has permission to view 2108 * @throws SystemException if a system exception occurred 2109 */ 2110 public static int filterCountByG_P_NotS(long groupId, long parentFolderId, 2111 int status) throws com.liferay.portal.kernel.exception.SystemException { 2112 return getPersistence() 2113 .filterCountByG_P_NotS(groupId, parentFolderId, status); 2114 } 2115 2116 /** 2117 * Caches the journal folder in the entity cache if it is enabled. 2118 * 2119 * @param journalFolder the journal folder 2120 */ 2121 public static void cacheResult( 2122 com.liferay.portlet.journal.model.JournalFolder journalFolder) { 2123 getPersistence().cacheResult(journalFolder); 2124 } 2125 2126 /** 2127 * Caches the journal folders in the entity cache if it is enabled. 2128 * 2129 * @param journalFolders the journal folders 2130 */ 2131 public static void cacheResult( 2132 java.util.List<com.liferay.portlet.journal.model.JournalFolder> journalFolders) { 2133 getPersistence().cacheResult(journalFolders); 2134 } 2135 2136 /** 2137 * Creates a new journal folder with the primary key. Does not add the journal folder to the database. 2138 * 2139 * @param folderId the primary key for the new journal folder 2140 * @return the new journal folder 2141 */ 2142 public static com.liferay.portlet.journal.model.JournalFolder create( 2143 long folderId) { 2144 return getPersistence().create(folderId); 2145 } 2146 2147 /** 2148 * Removes the journal folder with the primary key from the database. Also notifies the appropriate model listeners. 2149 * 2150 * @param folderId the primary key of the journal folder 2151 * @return the journal folder that was removed 2152 * @throws com.liferay.portlet.journal.NoSuchFolderException if a journal folder with the primary key could not be found 2153 * @throws SystemException if a system exception occurred 2154 */ 2155 public static com.liferay.portlet.journal.model.JournalFolder remove( 2156 long folderId) 2157 throws com.liferay.portal.kernel.exception.SystemException, 2158 com.liferay.portlet.journal.NoSuchFolderException { 2159 return getPersistence().remove(folderId); 2160 } 2161 2162 public static com.liferay.portlet.journal.model.JournalFolder updateImpl( 2163 com.liferay.portlet.journal.model.JournalFolder journalFolder) 2164 throws com.liferay.portal.kernel.exception.SystemException { 2165 return getPersistence().updateImpl(journalFolder); 2166 } 2167 2168 /** 2169 * Returns the journal folder with the primary key or throws a {@link com.liferay.portlet.journal.NoSuchFolderException} if it could not be found. 2170 * 2171 * @param folderId the primary key of the journal folder 2172 * @return the journal folder 2173 * @throws com.liferay.portlet.journal.NoSuchFolderException if a journal folder with the primary key could not be found 2174 * @throws SystemException if a system exception occurred 2175 */ 2176 public static com.liferay.portlet.journal.model.JournalFolder findByPrimaryKey( 2177 long folderId) 2178 throws com.liferay.portal.kernel.exception.SystemException, 2179 com.liferay.portlet.journal.NoSuchFolderException { 2180 return getPersistence().findByPrimaryKey(folderId); 2181 } 2182 2183 /** 2184 * Returns the journal folder with the primary key or returns <code>null</code> if it could not be found. 2185 * 2186 * @param folderId the primary key of the journal folder 2187 * @return the journal folder, or <code>null</code> if a journal folder with the primary key could not be found 2188 * @throws SystemException if a system exception occurred 2189 */ 2190 public static com.liferay.portlet.journal.model.JournalFolder fetchByPrimaryKey( 2191 long folderId) 2192 throws com.liferay.portal.kernel.exception.SystemException { 2193 return getPersistence().fetchByPrimaryKey(folderId); 2194 } 2195 2196 /** 2197 * Returns all the journal folders. 2198 * 2199 * @return the journal folders 2200 * @throws SystemException if a system exception occurred 2201 */ 2202 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findAll() 2203 throws com.liferay.portal.kernel.exception.SystemException { 2204 return getPersistence().findAll(); 2205 } 2206 2207 /** 2208 * Returns a range of all the journal folders. 2209 * 2210 * <p> 2211 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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. 2212 * </p> 2213 * 2214 * @param start the lower bound of the range of journal folders 2215 * @param end the upper bound of the range of journal folders (not inclusive) 2216 * @return the range of journal folders 2217 * @throws SystemException if a system exception occurred 2218 */ 2219 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findAll( 2220 int start, int end) 2221 throws com.liferay.portal.kernel.exception.SystemException { 2222 return getPersistence().findAll(start, end); 2223 } 2224 2225 /** 2226 * Returns an ordered range of all the journal folders. 2227 * 2228 * <p> 2229 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2230 * </p> 2231 * 2232 * @param start the lower bound of the range of journal folders 2233 * @param end the upper bound of the range of journal folders (not inclusive) 2234 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2235 * @return the ordered range of journal folders 2236 * @throws SystemException if a system exception occurred 2237 */ 2238 public static java.util.List<com.liferay.portlet.journal.model.JournalFolder> findAll( 2239 int start, int end, 2240 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2241 throws com.liferay.portal.kernel.exception.SystemException { 2242 return getPersistence().findAll(start, end, orderByComparator); 2243 } 2244 2245 /** 2246 * Removes all the journal folders from the database. 2247 * 2248 * @throws SystemException if a system exception occurred 2249 */ 2250 public static void removeAll() 2251 throws com.liferay.portal.kernel.exception.SystemException { 2252 getPersistence().removeAll(); 2253 } 2254 2255 /** 2256 * Returns the number of journal folders. 2257 * 2258 * @return the number of journal folders 2259 * @throws SystemException if a system exception occurred 2260 */ 2261 public static int countAll() 2262 throws com.liferay.portal.kernel.exception.SystemException { 2263 return getPersistence().countAll(); 2264 } 2265 2266 public static JournalFolderPersistence getPersistence() { 2267 if (_persistence == null) { 2268 _persistence = (JournalFolderPersistence)PortalBeanLocatorUtil.locate(JournalFolderPersistence.class.getName()); 2269 2270 ReferenceRegistry.registerReference(JournalFolderUtil.class, 2271 "_persistence"); 2272 } 2273 2274 return _persistence; 2275 } 2276 2277 /** 2278 * @deprecated As of 6.2.0 2279 */ 2280 public void setPersistence(JournalFolderPersistence persistence) { 2281 } 2282 2283 private static JournalFolderPersistence _persistence; 2284 }