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