001 /** 002 * Copyright (c) 2000-2011 Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portlet.journal.service.persistence; 016 017 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 018 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 019 import com.liferay.portal.kernel.exception.SystemException; 020 import com.liferay.portal.kernel.util.OrderByComparator; 021 import com.liferay.portal.kernel.util.ReferenceRegistry; 022 import com.liferay.portal.service.ServiceContext; 023 024 import com.liferay.portlet.journal.model.JournalStructure; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the journal structure service. This utility wraps {@link JournalStructurePersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 030 * 031 * <p> 032 * Caching information and settings can be found in <code>portal.properties</code> 033 * </p> 034 * 035 * @author Brian Wing Shun Chan 036 * @see JournalStructurePersistence 037 * @see JournalStructurePersistenceImpl 038 * @generated 039 */ 040 public class JournalStructureUtil { 041 /* 042 * NOTE FOR DEVELOPERS: 043 * 044 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 045 */ 046 047 /** 048 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 049 */ 050 public static void clearCache() { 051 getPersistence().clearCache(); 052 } 053 054 /** 055 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 056 */ 057 public static void clearCache(JournalStructure journalStructure) { 058 getPersistence().clearCache(journalStructure); 059 } 060 061 /** 062 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 063 */ 064 public long countWithDynamicQuery(DynamicQuery dynamicQuery) 065 throws SystemException { 066 return getPersistence().countWithDynamicQuery(dynamicQuery); 067 } 068 069 /** 070 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 071 */ 072 public static List<JournalStructure> findWithDynamicQuery( 073 DynamicQuery dynamicQuery) throws SystemException { 074 return getPersistence().findWithDynamicQuery(dynamicQuery); 075 } 076 077 /** 078 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 079 */ 080 public static List<JournalStructure> findWithDynamicQuery( 081 DynamicQuery dynamicQuery, int start, int end) 082 throws SystemException { 083 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 084 } 085 086 /** 087 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 088 */ 089 public static List<JournalStructure> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator orderByComparator) throws SystemException { 092 return getPersistence() 093 .findWithDynamicQuery(dynamicQuery, start, end, 094 orderByComparator); 095 } 096 097 /** 098 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean) 099 */ 100 public static JournalStructure update(JournalStructure journalStructure, 101 boolean merge) throws SystemException { 102 return getPersistence().update(journalStructure, merge); 103 } 104 105 /** 106 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, boolean, ServiceContext) 107 */ 108 public static JournalStructure update(JournalStructure journalStructure, 109 boolean merge, ServiceContext serviceContext) throws SystemException { 110 return getPersistence().update(journalStructure, merge, serviceContext); 111 } 112 113 /** 114 * Caches the journal structure in the entity cache if it is enabled. 115 * 116 * @param journalStructure the journal structure 117 */ 118 public static void cacheResult( 119 com.liferay.portlet.journal.model.JournalStructure journalStructure) { 120 getPersistence().cacheResult(journalStructure); 121 } 122 123 /** 124 * Caches the journal structures in the entity cache if it is enabled. 125 * 126 * @param journalStructures the journal structures 127 */ 128 public static void cacheResult( 129 java.util.List<com.liferay.portlet.journal.model.JournalStructure> journalStructures) { 130 getPersistence().cacheResult(journalStructures); 131 } 132 133 /** 134 * Creates a new journal structure with the primary key. Does not add the journal structure to the database. 135 * 136 * @param id the primary key for the new journal structure 137 * @return the new journal structure 138 */ 139 public static com.liferay.portlet.journal.model.JournalStructure create( 140 long id) { 141 return getPersistence().create(id); 142 } 143 144 /** 145 * Removes the journal structure with the primary key from the database. Also notifies the appropriate model listeners. 146 * 147 * @param id the primary key of the journal structure 148 * @return the journal structure that was removed 149 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 150 * @throws SystemException if a system exception occurred 151 */ 152 public static com.liferay.portlet.journal.model.JournalStructure remove( 153 long id) 154 throws com.liferay.portal.kernel.exception.SystemException, 155 com.liferay.portlet.journal.NoSuchStructureException { 156 return getPersistence().remove(id); 157 } 158 159 public static com.liferay.portlet.journal.model.JournalStructure updateImpl( 160 com.liferay.portlet.journal.model.JournalStructure journalStructure, 161 boolean merge) 162 throws com.liferay.portal.kernel.exception.SystemException { 163 return getPersistence().updateImpl(journalStructure, merge); 164 } 165 166 /** 167 * Returns the journal structure with the primary key or throws a {@link com.liferay.portlet.journal.NoSuchStructureException} if it could not be found. 168 * 169 * @param id the primary key of the journal structure 170 * @return the journal structure 171 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 172 * @throws SystemException if a system exception occurred 173 */ 174 public static com.liferay.portlet.journal.model.JournalStructure findByPrimaryKey( 175 long id) 176 throws com.liferay.portal.kernel.exception.SystemException, 177 com.liferay.portlet.journal.NoSuchStructureException { 178 return getPersistence().findByPrimaryKey(id); 179 } 180 181 /** 182 * Returns the journal structure with the primary key or returns <code>null</code> if it could not be found. 183 * 184 * @param id the primary key of the journal structure 185 * @return the journal structure, or <code>null</code> if a journal structure with the primary key could not be found 186 * @throws SystemException if a system exception occurred 187 */ 188 public static com.liferay.portlet.journal.model.JournalStructure fetchByPrimaryKey( 189 long id) throws com.liferay.portal.kernel.exception.SystemException { 190 return getPersistence().fetchByPrimaryKey(id); 191 } 192 193 /** 194 * Returns all the journal structures where uuid = ?. 195 * 196 * @param uuid the uuid 197 * @return the matching journal structures 198 * @throws SystemException if a system exception occurred 199 */ 200 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByUuid( 201 java.lang.String uuid) 202 throws com.liferay.portal.kernel.exception.SystemException { 203 return getPersistence().findByUuid(uuid); 204 } 205 206 /** 207 * Returns a range of all the journal structures where uuid = ?. 208 * 209 * <p> 210 * 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. 211 * </p> 212 * 213 * @param uuid the uuid 214 * @param start the lower bound of the range of journal structures 215 * @param end the upper bound of the range of journal structures (not inclusive) 216 * @return the range of matching journal structures 217 * @throws SystemException if a system exception occurred 218 */ 219 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByUuid( 220 java.lang.String uuid, int start, int end) 221 throws com.liferay.portal.kernel.exception.SystemException { 222 return getPersistence().findByUuid(uuid, start, end); 223 } 224 225 /** 226 * Returns an ordered range of all the journal structures where uuid = ?. 227 * 228 * <p> 229 * 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. 230 * </p> 231 * 232 * @param uuid the uuid 233 * @param start the lower bound of the range of journal structures 234 * @param end the upper bound of the range of journal structures (not inclusive) 235 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 236 * @return the ordered range of matching journal structures 237 * @throws SystemException if a system exception occurred 238 */ 239 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByUuid( 240 java.lang.String uuid, int start, int end, 241 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 242 throws com.liferay.portal.kernel.exception.SystemException { 243 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 244 } 245 246 /** 247 * Returns the first journal structure in the ordered set where uuid = ?. 248 * 249 * <p> 250 * 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. 251 * </p> 252 * 253 * @param uuid the uuid 254 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 255 * @return the first matching journal structure 256 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 257 * @throws SystemException if a system exception occurred 258 */ 259 public static com.liferay.portlet.journal.model.JournalStructure findByUuid_First( 260 java.lang.String uuid, 261 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 262 throws com.liferay.portal.kernel.exception.SystemException, 263 com.liferay.portlet.journal.NoSuchStructureException { 264 return getPersistence().findByUuid_First(uuid, orderByComparator); 265 } 266 267 /** 268 * Returns the last journal structure in the ordered set where uuid = ?. 269 * 270 * <p> 271 * 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. 272 * </p> 273 * 274 * @param uuid the uuid 275 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 276 * @return the last matching journal structure 277 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 278 * @throws SystemException if a system exception occurred 279 */ 280 public static com.liferay.portlet.journal.model.JournalStructure findByUuid_Last( 281 java.lang.String uuid, 282 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 283 throws com.liferay.portal.kernel.exception.SystemException, 284 com.liferay.portlet.journal.NoSuchStructureException { 285 return getPersistence().findByUuid_Last(uuid, orderByComparator); 286 } 287 288 /** 289 * Returns the journal structures before and after the current journal structure in the ordered set where uuid = ?. 290 * 291 * <p> 292 * 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. 293 * </p> 294 * 295 * @param id the primary key of the current journal structure 296 * @param uuid the uuid 297 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 298 * @return the previous, current, and next journal structure 299 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 300 * @throws SystemException if a system exception occurred 301 */ 302 public static com.liferay.portlet.journal.model.JournalStructure[] findByUuid_PrevAndNext( 303 long id, java.lang.String uuid, 304 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 305 throws com.liferay.portal.kernel.exception.SystemException, 306 com.liferay.portlet.journal.NoSuchStructureException { 307 return getPersistence() 308 .findByUuid_PrevAndNext(id, uuid, orderByComparator); 309 } 310 311 /** 312 * Returns the journal structure where uuid = ? and groupId = ? or throws a {@link com.liferay.portlet.journal.NoSuchStructureException} if it could not be found. 313 * 314 * @param uuid the uuid 315 * @param groupId the group ID 316 * @return the matching journal structure 317 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 318 * @throws SystemException if a system exception occurred 319 */ 320 public static com.liferay.portlet.journal.model.JournalStructure findByUUID_G( 321 java.lang.String uuid, long groupId) 322 throws com.liferay.portal.kernel.exception.SystemException, 323 com.liferay.portlet.journal.NoSuchStructureException { 324 return getPersistence().findByUUID_G(uuid, groupId); 325 } 326 327 /** 328 * Returns the journal structure where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 329 * 330 * @param uuid the uuid 331 * @param groupId the group ID 332 * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found 333 * @throws SystemException if a system exception occurred 334 */ 335 public static com.liferay.portlet.journal.model.JournalStructure fetchByUUID_G( 336 java.lang.String uuid, long groupId) 337 throws com.liferay.portal.kernel.exception.SystemException { 338 return getPersistence().fetchByUUID_G(uuid, groupId); 339 } 340 341 /** 342 * Returns the journal structure where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 343 * 344 * @param uuid the uuid 345 * @param groupId the group ID 346 * @param retrieveFromCache whether to use the finder cache 347 * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found 348 * @throws SystemException if a system exception occurred 349 */ 350 public static com.liferay.portlet.journal.model.JournalStructure fetchByUUID_G( 351 java.lang.String uuid, long groupId, boolean retrieveFromCache) 352 throws com.liferay.portal.kernel.exception.SystemException { 353 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 354 } 355 356 /** 357 * Returns all the journal structures where groupId = ?. 358 * 359 * @param groupId the group ID 360 * @return the matching journal structures 361 * @throws SystemException if a system exception occurred 362 */ 363 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId( 364 long groupId) 365 throws com.liferay.portal.kernel.exception.SystemException { 366 return getPersistence().findByGroupId(groupId); 367 } 368 369 /** 370 * Returns a range of all the journal structures where groupId = ?. 371 * 372 * <p> 373 * 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. 374 * </p> 375 * 376 * @param groupId the group ID 377 * @param start the lower bound of the range of journal structures 378 * @param end the upper bound of the range of journal structures (not inclusive) 379 * @return the range of matching journal structures 380 * @throws SystemException if a system exception occurred 381 */ 382 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId( 383 long groupId, int start, int end) 384 throws com.liferay.portal.kernel.exception.SystemException { 385 return getPersistence().findByGroupId(groupId, start, end); 386 } 387 388 /** 389 * Returns an ordered range of all the journal structures where groupId = ?. 390 * 391 * <p> 392 * 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. 393 * </p> 394 * 395 * @param groupId the group ID 396 * @param start the lower bound of the range of journal structures 397 * @param end the upper bound of the range of journal structures (not inclusive) 398 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 399 * @return the ordered range of matching journal structures 400 * @throws SystemException if a system exception occurred 401 */ 402 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByGroupId( 403 long groupId, int start, int end, 404 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 405 throws com.liferay.portal.kernel.exception.SystemException { 406 return getPersistence() 407 .findByGroupId(groupId, start, end, orderByComparator); 408 } 409 410 /** 411 * Returns the first journal structure in the ordered set where groupId = ?. 412 * 413 * <p> 414 * 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. 415 * </p> 416 * 417 * @param groupId the group ID 418 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 419 * @return the first matching journal structure 420 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 421 * @throws SystemException if a system exception occurred 422 */ 423 public static com.liferay.portlet.journal.model.JournalStructure findByGroupId_First( 424 long groupId, 425 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 426 throws com.liferay.portal.kernel.exception.SystemException, 427 com.liferay.portlet.journal.NoSuchStructureException { 428 return getPersistence().findByGroupId_First(groupId, orderByComparator); 429 } 430 431 /** 432 * Returns the last journal structure in the ordered set where groupId = ?. 433 * 434 * <p> 435 * 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. 436 * </p> 437 * 438 * @param groupId the group ID 439 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 440 * @return the last matching journal structure 441 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 442 * @throws SystemException if a system exception occurred 443 */ 444 public static com.liferay.portlet.journal.model.JournalStructure findByGroupId_Last( 445 long groupId, 446 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 447 throws com.liferay.portal.kernel.exception.SystemException, 448 com.liferay.portlet.journal.NoSuchStructureException { 449 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 450 } 451 452 /** 453 * Returns the journal structures before and after the current journal structure in the ordered set where groupId = ?. 454 * 455 * <p> 456 * 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. 457 * </p> 458 * 459 * @param id the primary key of the current journal structure 460 * @param groupId the group ID 461 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 462 * @return the previous, current, and next journal structure 463 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 464 * @throws SystemException if a system exception occurred 465 */ 466 public static com.liferay.portlet.journal.model.JournalStructure[] findByGroupId_PrevAndNext( 467 long id, long groupId, 468 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 469 throws com.liferay.portal.kernel.exception.SystemException, 470 com.liferay.portlet.journal.NoSuchStructureException { 471 return getPersistence() 472 .findByGroupId_PrevAndNext(id, groupId, orderByComparator); 473 } 474 475 /** 476 * Returns all the journal structures that the user has permission to view where groupId = ?. 477 * 478 * @param groupId the group ID 479 * @return the matching journal structures that the user has permission to view 480 * @throws SystemException if a system exception occurred 481 */ 482 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId( 483 long groupId) 484 throws com.liferay.portal.kernel.exception.SystemException { 485 return getPersistence().filterFindByGroupId(groupId); 486 } 487 488 /** 489 * Returns a range of all the journal structures that the user has permission to view where groupId = ?. 490 * 491 * <p> 492 * 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. 493 * </p> 494 * 495 * @param groupId the group ID 496 * @param start the lower bound of the range of journal structures 497 * @param end the upper bound of the range of journal structures (not inclusive) 498 * @return the range of matching journal structures that the user has permission to view 499 * @throws SystemException if a system exception occurred 500 */ 501 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId( 502 long groupId, int start, int end) 503 throws com.liferay.portal.kernel.exception.SystemException { 504 return getPersistence().filterFindByGroupId(groupId, start, end); 505 } 506 507 /** 508 * Returns an ordered range of all the journal structures that the user has permissions to view where groupId = ?. 509 * 510 * <p> 511 * 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. 512 * </p> 513 * 514 * @param groupId the group ID 515 * @param start the lower bound of the range of journal structures 516 * @param end the upper bound of the range of journal structures (not inclusive) 517 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 518 * @return the ordered range of matching journal structures that the user has permission to view 519 * @throws SystemException if a system exception occurred 520 */ 521 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByGroupId( 522 long groupId, int start, int end, 523 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 524 throws com.liferay.portal.kernel.exception.SystemException { 525 return getPersistence() 526 .filterFindByGroupId(groupId, start, end, orderByComparator); 527 } 528 529 /** 530 * Returns the journal structures before and after the current journal structure in the ordered set of journal structures that the user has permission to view where groupId = ?. 531 * 532 * @param id the primary key of the current journal structure 533 * @param groupId the group ID 534 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 535 * @return the previous, current, and next journal structure 536 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 537 * @throws SystemException if a system exception occurred 538 */ 539 public static com.liferay.portlet.journal.model.JournalStructure[] filterFindByGroupId_PrevAndNext( 540 long id, long groupId, 541 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 542 throws com.liferay.portal.kernel.exception.SystemException, 543 com.liferay.portlet.journal.NoSuchStructureException { 544 return getPersistence() 545 .filterFindByGroupId_PrevAndNext(id, groupId, 546 orderByComparator); 547 } 548 549 /** 550 * Returns all the journal structures where structureId = ?. 551 * 552 * @param structureId the structure ID 553 * @return the matching journal structures 554 * @throws SystemException if a system exception occurred 555 */ 556 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByStructureId( 557 java.lang.String structureId) 558 throws com.liferay.portal.kernel.exception.SystemException { 559 return getPersistence().findByStructureId(structureId); 560 } 561 562 /** 563 * Returns a range of all the journal structures where structureId = ?. 564 * 565 * <p> 566 * 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. 567 * </p> 568 * 569 * @param structureId the structure ID 570 * @param start the lower bound of the range of journal structures 571 * @param end the upper bound of the range of journal structures (not inclusive) 572 * @return the range of matching journal structures 573 * @throws SystemException if a system exception occurred 574 */ 575 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByStructureId( 576 java.lang.String structureId, int start, int end) 577 throws com.liferay.portal.kernel.exception.SystemException { 578 return getPersistence().findByStructureId(structureId, start, end); 579 } 580 581 /** 582 * Returns an ordered range of all the journal structures where structureId = ?. 583 * 584 * <p> 585 * 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. 586 * </p> 587 * 588 * @param structureId the structure ID 589 * @param start the lower bound of the range of journal structures 590 * @param end the upper bound of the range of journal structures (not inclusive) 591 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 592 * @return the ordered range of matching journal structures 593 * @throws SystemException if a system exception occurred 594 */ 595 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByStructureId( 596 java.lang.String structureId, int start, int end, 597 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 598 throws com.liferay.portal.kernel.exception.SystemException { 599 return getPersistence() 600 .findByStructureId(structureId, start, end, orderByComparator); 601 } 602 603 /** 604 * Returns the first journal structure in the ordered set where structureId = ?. 605 * 606 * <p> 607 * 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. 608 * </p> 609 * 610 * @param structureId the structure ID 611 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 612 * @return the first matching journal structure 613 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 614 * @throws SystemException if a system exception occurred 615 */ 616 public static com.liferay.portlet.journal.model.JournalStructure findByStructureId_First( 617 java.lang.String structureId, 618 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 619 throws com.liferay.portal.kernel.exception.SystemException, 620 com.liferay.portlet.journal.NoSuchStructureException { 621 return getPersistence() 622 .findByStructureId_First(structureId, orderByComparator); 623 } 624 625 /** 626 * Returns the last journal structure in the ordered set where structureId = ?. 627 * 628 * <p> 629 * 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. 630 * </p> 631 * 632 * @param structureId the structure ID 633 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 634 * @return the last matching journal structure 635 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 636 * @throws SystemException if a system exception occurred 637 */ 638 public static com.liferay.portlet.journal.model.JournalStructure findByStructureId_Last( 639 java.lang.String structureId, 640 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 641 throws com.liferay.portal.kernel.exception.SystemException, 642 com.liferay.portlet.journal.NoSuchStructureException { 643 return getPersistence() 644 .findByStructureId_Last(structureId, orderByComparator); 645 } 646 647 /** 648 * Returns the journal structures before and after the current journal structure in the ordered set where structureId = ?. 649 * 650 * <p> 651 * 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. 652 * </p> 653 * 654 * @param id the primary key of the current journal structure 655 * @param structureId the structure ID 656 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 657 * @return the previous, current, and next journal structure 658 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 659 * @throws SystemException if a system exception occurred 660 */ 661 public static com.liferay.portlet.journal.model.JournalStructure[] findByStructureId_PrevAndNext( 662 long id, java.lang.String structureId, 663 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 664 throws com.liferay.portal.kernel.exception.SystemException, 665 com.liferay.portlet.journal.NoSuchStructureException { 666 return getPersistence() 667 .findByStructureId_PrevAndNext(id, structureId, 668 orderByComparator); 669 } 670 671 /** 672 * Returns the journal structure where groupId = ? and structureId = ? or throws a {@link com.liferay.portlet.journal.NoSuchStructureException} if it could not be found. 673 * 674 * @param groupId the group ID 675 * @param structureId the structure ID 676 * @return the matching journal structure 677 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 678 * @throws SystemException if a system exception occurred 679 */ 680 public static com.liferay.portlet.journal.model.JournalStructure findByG_S( 681 long groupId, java.lang.String structureId) 682 throws com.liferay.portal.kernel.exception.SystemException, 683 com.liferay.portlet.journal.NoSuchStructureException { 684 return getPersistence().findByG_S(groupId, structureId); 685 } 686 687 /** 688 * Returns the journal structure where groupId = ? and structureId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 689 * 690 * @param groupId the group ID 691 * @param structureId the structure ID 692 * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found 693 * @throws SystemException if a system exception occurred 694 */ 695 public static com.liferay.portlet.journal.model.JournalStructure fetchByG_S( 696 long groupId, java.lang.String structureId) 697 throws com.liferay.portal.kernel.exception.SystemException { 698 return getPersistence().fetchByG_S(groupId, structureId); 699 } 700 701 /** 702 * Returns the journal structure where groupId = ? and structureId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 703 * 704 * @param groupId the group ID 705 * @param structureId the structure ID 706 * @param retrieveFromCache whether to use the finder cache 707 * @return the matching journal structure, or <code>null</code> if a matching journal structure could not be found 708 * @throws SystemException if a system exception occurred 709 */ 710 public static com.liferay.portlet.journal.model.JournalStructure fetchByG_S( 711 long groupId, java.lang.String structureId, boolean retrieveFromCache) 712 throws com.liferay.portal.kernel.exception.SystemException { 713 return getPersistence() 714 .fetchByG_S(groupId, structureId, retrieveFromCache); 715 } 716 717 /** 718 * Returns all the journal structures where groupId = ? and parentStructureId = ?. 719 * 720 * @param groupId the group ID 721 * @param parentStructureId the parent structure ID 722 * @return the matching journal structures 723 * @throws SystemException if a system exception occurred 724 */ 725 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByG_P( 726 long groupId, java.lang.String parentStructureId) 727 throws com.liferay.portal.kernel.exception.SystemException { 728 return getPersistence().findByG_P(groupId, parentStructureId); 729 } 730 731 /** 732 * Returns a range of all the journal structures where groupId = ? and parentStructureId = ?. 733 * 734 * <p> 735 * 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. 736 * </p> 737 * 738 * @param groupId the group ID 739 * @param parentStructureId the parent structure ID 740 * @param start the lower bound of the range of journal structures 741 * @param end the upper bound of the range of journal structures (not inclusive) 742 * @return the range of matching journal structures 743 * @throws SystemException if a system exception occurred 744 */ 745 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByG_P( 746 long groupId, java.lang.String parentStructureId, int start, int end) 747 throws com.liferay.portal.kernel.exception.SystemException { 748 return getPersistence().findByG_P(groupId, parentStructureId, start, end); 749 } 750 751 /** 752 * Returns an ordered range of all the journal structures where groupId = ? and parentStructureId = ?. 753 * 754 * <p> 755 * 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. 756 * </p> 757 * 758 * @param groupId the group ID 759 * @param parentStructureId the parent structure ID 760 * @param start the lower bound of the range of journal structures 761 * @param end the upper bound of the range of journal structures (not inclusive) 762 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 763 * @return the ordered range of matching journal structures 764 * @throws SystemException if a system exception occurred 765 */ 766 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findByG_P( 767 long groupId, java.lang.String parentStructureId, int start, int end, 768 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 769 throws com.liferay.portal.kernel.exception.SystemException { 770 return getPersistence() 771 .findByG_P(groupId, parentStructureId, start, end, 772 orderByComparator); 773 } 774 775 /** 776 * Returns the first journal structure in the ordered set where groupId = ? and parentStructureId = ?. 777 * 778 * <p> 779 * 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. 780 * </p> 781 * 782 * @param groupId the group ID 783 * @param parentStructureId the parent structure ID 784 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 785 * @return the first matching journal structure 786 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 787 * @throws SystemException if a system exception occurred 788 */ 789 public static com.liferay.portlet.journal.model.JournalStructure findByG_P_First( 790 long groupId, java.lang.String parentStructureId, 791 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 792 throws com.liferay.portal.kernel.exception.SystemException, 793 com.liferay.portlet.journal.NoSuchStructureException { 794 return getPersistence() 795 .findByG_P_First(groupId, parentStructureId, 796 orderByComparator); 797 } 798 799 /** 800 * Returns the last journal structure in the ordered set where groupId = ? and parentStructureId = ?. 801 * 802 * <p> 803 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 804 * </p> 805 * 806 * @param groupId the group ID 807 * @param parentStructureId the parent structure ID 808 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 809 * @return the last matching journal structure 810 * @throws com.liferay.portlet.journal.NoSuchStructureException if a matching journal structure could not be found 811 * @throws SystemException if a system exception occurred 812 */ 813 public static com.liferay.portlet.journal.model.JournalStructure findByG_P_Last( 814 long groupId, java.lang.String parentStructureId, 815 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 816 throws com.liferay.portal.kernel.exception.SystemException, 817 com.liferay.portlet.journal.NoSuchStructureException { 818 return getPersistence() 819 .findByG_P_Last(groupId, parentStructureId, orderByComparator); 820 } 821 822 /** 823 * Returns the journal structures before and after the current journal structure in the ordered set where groupId = ? and parentStructureId = ?. 824 * 825 * <p> 826 * 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. 827 * </p> 828 * 829 * @param id the primary key of the current journal structure 830 * @param groupId the group ID 831 * @param parentStructureId the parent structure ID 832 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 833 * @return the previous, current, and next journal structure 834 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 835 * @throws SystemException if a system exception occurred 836 */ 837 public static com.liferay.portlet.journal.model.JournalStructure[] findByG_P_PrevAndNext( 838 long id, long groupId, java.lang.String parentStructureId, 839 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 840 throws com.liferay.portal.kernel.exception.SystemException, 841 com.liferay.portlet.journal.NoSuchStructureException { 842 return getPersistence() 843 .findByG_P_PrevAndNext(id, groupId, parentStructureId, 844 orderByComparator); 845 } 846 847 /** 848 * Returns all the journal structures that the user has permission to view where groupId = ? and parentStructureId = ?. 849 * 850 * @param groupId the group ID 851 * @param parentStructureId the parent structure ID 852 * @return the matching journal structures that the user has permission to view 853 * @throws SystemException if a system exception occurred 854 */ 855 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByG_P( 856 long groupId, java.lang.String parentStructureId) 857 throws com.liferay.portal.kernel.exception.SystemException { 858 return getPersistence().filterFindByG_P(groupId, parentStructureId); 859 } 860 861 /** 862 * Returns a range of all the journal structures that the user has permission to view where groupId = ? and parentStructureId = ?. 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. 866 * </p> 867 * 868 * @param groupId the group ID 869 * @param parentStructureId the parent structure ID 870 * @param start the lower bound of the range of journal structures 871 * @param end the upper bound of the range of journal structures (not inclusive) 872 * @return the range of matching journal structures that the user has permission to view 873 * @throws SystemException if a system exception occurred 874 */ 875 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByG_P( 876 long groupId, java.lang.String parentStructureId, int start, int end) 877 throws com.liferay.portal.kernel.exception.SystemException { 878 return getPersistence() 879 .filterFindByG_P(groupId, parentStructureId, start, end); 880 } 881 882 /** 883 * Returns an ordered range of all the journal structures that the user has permissions to view where groupId = ? and parentStructureId = ?. 884 * 885 * <p> 886 * 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. 887 * </p> 888 * 889 * @param groupId the group ID 890 * @param parentStructureId the parent structure ID 891 * @param start the lower bound of the range of journal structures 892 * @param end the upper bound of the range of journal structures (not inclusive) 893 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 894 * @return the ordered range of matching journal structures that the user has permission to view 895 * @throws SystemException if a system exception occurred 896 */ 897 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> filterFindByG_P( 898 long groupId, java.lang.String parentStructureId, int start, int end, 899 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 900 throws com.liferay.portal.kernel.exception.SystemException { 901 return getPersistence() 902 .filterFindByG_P(groupId, parentStructureId, start, end, 903 orderByComparator); 904 } 905 906 /** 907 * Returns the journal structures before and after the current journal structure in the ordered set of journal structures that the user has permission to view where groupId = ? and parentStructureId = ?. 908 * 909 * @param id the primary key of the current journal structure 910 * @param groupId the group ID 911 * @param parentStructureId the parent structure ID 912 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 913 * @return the previous, current, and next journal structure 914 * @throws com.liferay.portlet.journal.NoSuchStructureException if a journal structure with the primary key could not be found 915 * @throws SystemException if a system exception occurred 916 */ 917 public static com.liferay.portlet.journal.model.JournalStructure[] filterFindByG_P_PrevAndNext( 918 long id, long groupId, java.lang.String parentStructureId, 919 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 920 throws com.liferay.portal.kernel.exception.SystemException, 921 com.liferay.portlet.journal.NoSuchStructureException { 922 return getPersistence() 923 .filterFindByG_P_PrevAndNext(id, groupId, parentStructureId, 924 orderByComparator); 925 } 926 927 /** 928 * Returns all the journal structures. 929 * 930 * @return the journal structures 931 * @throws SystemException if a system exception occurred 932 */ 933 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findAll() 934 throws com.liferay.portal.kernel.exception.SystemException { 935 return getPersistence().findAll(); 936 } 937 938 /** 939 * Returns a range of all the journal structures. 940 * 941 * <p> 942 * 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. 943 * </p> 944 * 945 * @param start the lower bound of the range of journal structures 946 * @param end the upper bound of the range of journal structures (not inclusive) 947 * @return the range of journal structures 948 * @throws SystemException if a system exception occurred 949 */ 950 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findAll( 951 int start, int end) 952 throws com.liferay.portal.kernel.exception.SystemException { 953 return getPersistence().findAll(start, end); 954 } 955 956 /** 957 * Returns an ordered range of all the journal structures. 958 * 959 * <p> 960 * 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. 961 * </p> 962 * 963 * @param start the lower bound of the range of journal structures 964 * @param end the upper bound of the range of journal structures (not inclusive) 965 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 966 * @return the ordered range of journal structures 967 * @throws SystemException if a system exception occurred 968 */ 969 public static java.util.List<com.liferay.portlet.journal.model.JournalStructure> findAll( 970 int start, int end, 971 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 972 throws com.liferay.portal.kernel.exception.SystemException { 973 return getPersistence().findAll(start, end, orderByComparator); 974 } 975 976 /** 977 * Removes all the journal structures where uuid = ? from the database. 978 * 979 * @param uuid the uuid 980 * @throws SystemException if a system exception occurred 981 */ 982 public static void removeByUuid(java.lang.String uuid) 983 throws com.liferay.portal.kernel.exception.SystemException { 984 getPersistence().removeByUuid(uuid); 985 } 986 987 /** 988 * Removes the journal structure where uuid = ? and groupId = ? from the database. 989 * 990 * @param uuid the uuid 991 * @param groupId the group ID 992 * @throws SystemException if a system exception occurred 993 */ 994 public static void removeByUUID_G(java.lang.String uuid, long groupId) 995 throws com.liferay.portal.kernel.exception.SystemException, 996 com.liferay.portlet.journal.NoSuchStructureException { 997 getPersistence().removeByUUID_G(uuid, groupId); 998 } 999 1000 /** 1001 * Removes all the journal structures where groupId = ? from the database. 1002 * 1003 * @param groupId the group ID 1004 * @throws SystemException if a system exception occurred 1005 */ 1006 public static void removeByGroupId(long groupId) 1007 throws com.liferay.portal.kernel.exception.SystemException { 1008 getPersistence().removeByGroupId(groupId); 1009 } 1010 1011 /** 1012 * Removes all the journal structures where structureId = ? from the database. 1013 * 1014 * @param structureId the structure ID 1015 * @throws SystemException if a system exception occurred 1016 */ 1017 public static void removeByStructureId(java.lang.String structureId) 1018 throws com.liferay.portal.kernel.exception.SystemException { 1019 getPersistence().removeByStructureId(structureId); 1020 } 1021 1022 /** 1023 * Removes the journal structure where groupId = ? and structureId = ? from the database. 1024 * 1025 * @param groupId the group ID 1026 * @param structureId the structure ID 1027 * @throws SystemException if a system exception occurred 1028 */ 1029 public static void removeByG_S(long groupId, java.lang.String structureId) 1030 throws com.liferay.portal.kernel.exception.SystemException, 1031 com.liferay.portlet.journal.NoSuchStructureException { 1032 getPersistence().removeByG_S(groupId, structureId); 1033 } 1034 1035 /** 1036 * Removes all the journal structures where groupId = ? and parentStructureId = ? from the database. 1037 * 1038 * @param groupId the group ID 1039 * @param parentStructureId the parent structure ID 1040 * @throws SystemException if a system exception occurred 1041 */ 1042 public static void removeByG_P(long groupId, 1043 java.lang.String parentStructureId) 1044 throws com.liferay.portal.kernel.exception.SystemException { 1045 getPersistence().removeByG_P(groupId, parentStructureId); 1046 } 1047 1048 /** 1049 * Removes all the journal structures from the database. 1050 * 1051 * @throws SystemException if a system exception occurred 1052 */ 1053 public static void removeAll() 1054 throws com.liferay.portal.kernel.exception.SystemException { 1055 getPersistence().removeAll(); 1056 } 1057 1058 /** 1059 * Returns the number of journal structures where uuid = ?. 1060 * 1061 * @param uuid the uuid 1062 * @return the number of matching journal structures 1063 * @throws SystemException if a system exception occurred 1064 */ 1065 public static int countByUuid(java.lang.String uuid) 1066 throws com.liferay.portal.kernel.exception.SystemException { 1067 return getPersistence().countByUuid(uuid); 1068 } 1069 1070 /** 1071 * Returns the number of journal structures where uuid = ? and groupId = ?. 1072 * 1073 * @param uuid the uuid 1074 * @param groupId the group ID 1075 * @return the number of matching journal structures 1076 * @throws SystemException if a system exception occurred 1077 */ 1078 public static int countByUUID_G(java.lang.String uuid, long groupId) 1079 throws com.liferay.portal.kernel.exception.SystemException { 1080 return getPersistence().countByUUID_G(uuid, groupId); 1081 } 1082 1083 /** 1084 * Returns the number of journal structures where groupId = ?. 1085 * 1086 * @param groupId the group ID 1087 * @return the number of matching journal structures 1088 * @throws SystemException if a system exception occurred 1089 */ 1090 public static int countByGroupId(long groupId) 1091 throws com.liferay.portal.kernel.exception.SystemException { 1092 return getPersistence().countByGroupId(groupId); 1093 } 1094 1095 /** 1096 * Returns the number of journal structures that the user has permission to view where groupId = ?. 1097 * 1098 * @param groupId the group ID 1099 * @return the number of matching journal structures that the user has permission to view 1100 * @throws SystemException if a system exception occurred 1101 */ 1102 public static int filterCountByGroupId(long groupId) 1103 throws com.liferay.portal.kernel.exception.SystemException { 1104 return getPersistence().filterCountByGroupId(groupId); 1105 } 1106 1107 /** 1108 * Returns the number of journal structures where structureId = ?. 1109 * 1110 * @param structureId the structure ID 1111 * @return the number of matching journal structures 1112 * @throws SystemException if a system exception occurred 1113 */ 1114 public static int countByStructureId(java.lang.String structureId) 1115 throws com.liferay.portal.kernel.exception.SystemException { 1116 return getPersistence().countByStructureId(structureId); 1117 } 1118 1119 /** 1120 * Returns the number of journal structures where groupId = ? and structureId = ?. 1121 * 1122 * @param groupId the group ID 1123 * @param structureId the structure ID 1124 * @return the number of matching journal structures 1125 * @throws SystemException if a system exception occurred 1126 */ 1127 public static int countByG_S(long groupId, java.lang.String structureId) 1128 throws com.liferay.portal.kernel.exception.SystemException { 1129 return getPersistence().countByG_S(groupId, structureId); 1130 } 1131 1132 /** 1133 * Returns the number of journal structures where groupId = ? and parentStructureId = ?. 1134 * 1135 * @param groupId the group ID 1136 * @param parentStructureId the parent structure ID 1137 * @return the number of matching journal structures 1138 * @throws SystemException if a system exception occurred 1139 */ 1140 public static int countByG_P(long groupId, 1141 java.lang.String parentStructureId) 1142 throws com.liferay.portal.kernel.exception.SystemException { 1143 return getPersistence().countByG_P(groupId, parentStructureId); 1144 } 1145 1146 /** 1147 * Returns the number of journal structures that the user has permission to view where groupId = ? and parentStructureId = ?. 1148 * 1149 * @param groupId the group ID 1150 * @param parentStructureId the parent structure ID 1151 * @return the number of matching journal structures that the user has permission to view 1152 * @throws SystemException if a system exception occurred 1153 */ 1154 public static int filterCountByG_P(long groupId, 1155 java.lang.String parentStructureId) 1156 throws com.liferay.portal.kernel.exception.SystemException { 1157 return getPersistence().filterCountByG_P(groupId, parentStructureId); 1158 } 1159 1160 /** 1161 * Returns the number of journal structures. 1162 * 1163 * @return the number of journal structures 1164 * @throws SystemException if a system exception occurred 1165 */ 1166 public static int countAll() 1167 throws com.liferay.portal.kernel.exception.SystemException { 1168 return getPersistence().countAll(); 1169 } 1170 1171 public static JournalStructurePersistence getPersistence() { 1172 if (_persistence == null) { 1173 _persistence = (JournalStructurePersistence)PortalBeanLocatorUtil.locate(JournalStructurePersistence.class.getName()); 1174 1175 ReferenceRegistry.registerReference(JournalStructureUtil.class, 1176 "_persistence"); 1177 } 1178 1179 return _persistence; 1180 } 1181 1182 public void setPersistence(JournalStructurePersistence persistence) { 1183 _persistence = persistence; 1184 1185 ReferenceRegistry.registerReference(JournalStructureUtil.class, 1186 "_persistence"); 1187 } 1188 1189 private static JournalStructurePersistence _persistence; 1190 }