001 /** 002 * Copyright (c) 2000-2012 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.softwarecatalog.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.softwarecatalog.model.SCLicense; 025 026 import java.util.List; 027 028 /** 029 * The persistence utility for the s c license service. This utility wraps {@link SCLicensePersistenceImpl} 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 SCLicensePersistence 037 * @see SCLicensePersistenceImpl 038 * @generated 039 */ 040 public class SCLicenseUtil { 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(SCLicense scLicense) { 058 getPersistence().clearCache(scLicense); 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<SCLicense> 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<SCLicense> 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<SCLicense> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator orderByComparator) throws SystemException { 092 return getPersistence() 093 .findWithDynamicQuery(dynamicQuery, start, end, 094 orderByComparator); 095 } 096 097 /** 098 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 099 */ 100 public static SCLicense update(SCLicense scLicense) 101 throws SystemException { 102 return getPersistence().update(scLicense); 103 } 104 105 /** 106 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 107 */ 108 public static SCLicense update(SCLicense scLicense, 109 ServiceContext serviceContext) throws SystemException { 110 return getPersistence().update(scLicense, serviceContext); 111 } 112 113 /** 114 * Caches the s c license in the entity cache if it is enabled. 115 * 116 * @param scLicense the s c license 117 */ 118 public static void cacheResult( 119 com.liferay.portlet.softwarecatalog.model.SCLicense scLicense) { 120 getPersistence().cacheResult(scLicense); 121 } 122 123 /** 124 * Caches the s c licenses in the entity cache if it is enabled. 125 * 126 * @param scLicenses the s c licenses 127 */ 128 public static void cacheResult( 129 java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> scLicenses) { 130 getPersistence().cacheResult(scLicenses); 131 } 132 133 /** 134 * Creates a new s c license with the primary key. Does not add the s c license to the database. 135 * 136 * @param licenseId the primary key for the new s c license 137 * @return the new s c license 138 */ 139 public static com.liferay.portlet.softwarecatalog.model.SCLicense create( 140 long licenseId) { 141 return getPersistence().create(licenseId); 142 } 143 144 /** 145 * Removes the s c license with the primary key from the database. Also notifies the appropriate model listeners. 146 * 147 * @param licenseId the primary key of the s c license 148 * @return the s c license that was removed 149 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found 150 * @throws SystemException if a system exception occurred 151 */ 152 public static com.liferay.portlet.softwarecatalog.model.SCLicense remove( 153 long licenseId) 154 throws com.liferay.portal.kernel.exception.SystemException, 155 com.liferay.portlet.softwarecatalog.NoSuchLicenseException { 156 return getPersistence().remove(licenseId); 157 } 158 159 public static com.liferay.portlet.softwarecatalog.model.SCLicense updateImpl( 160 com.liferay.portlet.softwarecatalog.model.SCLicense scLicense) 161 throws com.liferay.portal.kernel.exception.SystemException { 162 return getPersistence().updateImpl(scLicense); 163 } 164 165 /** 166 * Returns the s c license with the primary key or throws a {@link com.liferay.portlet.softwarecatalog.NoSuchLicenseException} if it could not be found. 167 * 168 * @param licenseId the primary key of the s c license 169 * @return the s c license 170 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found 171 * @throws SystemException if a system exception occurred 172 */ 173 public static com.liferay.portlet.softwarecatalog.model.SCLicense findByPrimaryKey( 174 long licenseId) 175 throws com.liferay.portal.kernel.exception.SystemException, 176 com.liferay.portlet.softwarecatalog.NoSuchLicenseException { 177 return getPersistence().findByPrimaryKey(licenseId); 178 } 179 180 /** 181 * Returns the s c license with the primary key or returns <code>null</code> if it could not be found. 182 * 183 * @param licenseId the primary key of the s c license 184 * @return the s c license, or <code>null</code> if a s c license with the primary key could not be found 185 * @throws SystemException if a system exception occurred 186 */ 187 public static com.liferay.portlet.softwarecatalog.model.SCLicense fetchByPrimaryKey( 188 long licenseId) 189 throws com.liferay.portal.kernel.exception.SystemException { 190 return getPersistence().fetchByPrimaryKey(licenseId); 191 } 192 193 /** 194 * Returns all the s c licenses where active = ?. 195 * 196 * @param active the active 197 * @return the matching s c licenses 198 * @throws SystemException if a system exception occurred 199 */ 200 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByActive( 201 boolean active) 202 throws com.liferay.portal.kernel.exception.SystemException { 203 return getPersistence().findByActive(active); 204 } 205 206 /** 207 * Returns a range of all the s c licenses where active = ?. 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 active the active 214 * @param start the lower bound of the range of s c licenses 215 * @param end the upper bound of the range of s c licenses (not inclusive) 216 * @return the range of matching s c licenses 217 * @throws SystemException if a system exception occurred 218 */ 219 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByActive( 220 boolean active, int start, int end) 221 throws com.liferay.portal.kernel.exception.SystemException { 222 return getPersistence().findByActive(active, start, end); 223 } 224 225 /** 226 * Returns an ordered range of all the s c licenses where active = ?. 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 active the active 233 * @param start the lower bound of the range of s c licenses 234 * @param end the upper bound of the range of s c licenses (not inclusive) 235 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 236 * @return the ordered range of matching s c licenses 237 * @throws SystemException if a system exception occurred 238 */ 239 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByActive( 240 boolean active, int start, int end, 241 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 242 throws com.liferay.portal.kernel.exception.SystemException { 243 return getPersistence() 244 .findByActive(active, start, end, orderByComparator); 245 } 246 247 /** 248 * Returns the first s c license in the ordered set where active = ?. 249 * 250 * @param active the active 251 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 252 * @return the first matching s c license 253 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a matching s c license could not be found 254 * @throws SystemException if a system exception occurred 255 */ 256 public static com.liferay.portlet.softwarecatalog.model.SCLicense findByActive_First( 257 boolean active, 258 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 259 throws com.liferay.portal.kernel.exception.SystemException, 260 com.liferay.portlet.softwarecatalog.NoSuchLicenseException { 261 return getPersistence().findByActive_First(active, orderByComparator); 262 } 263 264 /** 265 * Returns the first s c license in the ordered set where active = ?. 266 * 267 * @param active the active 268 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 269 * @return the first matching s c license, or <code>null</code> if a matching s c license could not be found 270 * @throws SystemException if a system exception occurred 271 */ 272 public static com.liferay.portlet.softwarecatalog.model.SCLicense fetchByActive_First( 273 boolean active, 274 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 275 throws com.liferay.portal.kernel.exception.SystemException { 276 return getPersistence().fetchByActive_First(active, orderByComparator); 277 } 278 279 /** 280 * Returns the last s c license in the ordered set where active = ?. 281 * 282 * @param active the active 283 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 284 * @return the last matching s c license 285 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a matching s c license could not be found 286 * @throws SystemException if a system exception occurred 287 */ 288 public static com.liferay.portlet.softwarecatalog.model.SCLicense findByActive_Last( 289 boolean active, 290 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 291 throws com.liferay.portal.kernel.exception.SystemException, 292 com.liferay.portlet.softwarecatalog.NoSuchLicenseException { 293 return getPersistence().findByActive_Last(active, orderByComparator); 294 } 295 296 /** 297 * Returns the last s c license in the ordered set where active = ?. 298 * 299 * @param active the active 300 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 301 * @return the last matching s c license, or <code>null</code> if a matching s c license could not be found 302 * @throws SystemException if a system exception occurred 303 */ 304 public static com.liferay.portlet.softwarecatalog.model.SCLicense fetchByActive_Last( 305 boolean active, 306 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 307 throws com.liferay.portal.kernel.exception.SystemException { 308 return getPersistence().fetchByActive_Last(active, orderByComparator); 309 } 310 311 /** 312 * Returns the s c licenses before and after the current s c license in the ordered set where active = ?. 313 * 314 * @param licenseId the primary key of the current s c license 315 * @param active the active 316 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 317 * @return the previous, current, and next s c license 318 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found 319 * @throws SystemException if a system exception occurred 320 */ 321 public static com.liferay.portlet.softwarecatalog.model.SCLicense[] findByActive_PrevAndNext( 322 long licenseId, boolean active, 323 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 324 throws com.liferay.portal.kernel.exception.SystemException, 325 com.liferay.portlet.softwarecatalog.NoSuchLicenseException { 326 return getPersistence() 327 .findByActive_PrevAndNext(licenseId, active, 328 orderByComparator); 329 } 330 331 /** 332 * Returns all the s c licenses that the user has permission to view where active = ?. 333 * 334 * @param active the active 335 * @return the matching s c licenses that the user has permission to view 336 * @throws SystemException if a system exception occurred 337 */ 338 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByActive( 339 boolean active) 340 throws com.liferay.portal.kernel.exception.SystemException { 341 return getPersistence().filterFindByActive(active); 342 } 343 344 /** 345 * Returns a range of all the s c licenses that the user has permission to view where active = ?. 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. 349 * </p> 350 * 351 * @param active the active 352 * @param start the lower bound of the range of s c licenses 353 * @param end the upper bound of the range of s c licenses (not inclusive) 354 * @return the range of matching s c licenses that the user has permission to view 355 * @throws SystemException if a system exception occurred 356 */ 357 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByActive( 358 boolean active, int start, int end) 359 throws com.liferay.portal.kernel.exception.SystemException { 360 return getPersistence().filterFindByActive(active, start, end); 361 } 362 363 /** 364 * Returns an ordered range of all the s c licenses that the user has permissions to view where active = ?. 365 * 366 * <p> 367 * 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. 368 * </p> 369 * 370 * @param active the active 371 * @param start the lower bound of the range of s c licenses 372 * @param end the upper bound of the range of s c licenses (not inclusive) 373 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 374 * @return the ordered range of matching s c licenses that the user has permission to view 375 * @throws SystemException if a system exception occurred 376 */ 377 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByActive( 378 boolean active, int start, int end, 379 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 380 throws com.liferay.portal.kernel.exception.SystemException { 381 return getPersistence() 382 .filterFindByActive(active, start, end, orderByComparator); 383 } 384 385 /** 386 * Returns the s c licenses before and after the current s c license in the ordered set of s c licenses that the user has permission to view where active = ?. 387 * 388 * @param licenseId the primary key of the current s c license 389 * @param active the active 390 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 391 * @return the previous, current, and next s c license 392 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found 393 * @throws SystemException if a system exception occurred 394 */ 395 public static com.liferay.portlet.softwarecatalog.model.SCLicense[] filterFindByActive_PrevAndNext( 396 long licenseId, boolean active, 397 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 398 throws com.liferay.portal.kernel.exception.SystemException, 399 com.liferay.portlet.softwarecatalog.NoSuchLicenseException { 400 return getPersistence() 401 .filterFindByActive_PrevAndNext(licenseId, active, 402 orderByComparator); 403 } 404 405 /** 406 * Returns all the s c licenses where active = ? and recommended = ?. 407 * 408 * @param active the active 409 * @param recommended the recommended 410 * @return the matching s c licenses 411 * @throws SystemException if a system exception occurred 412 */ 413 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByA_R( 414 boolean active, boolean recommended) 415 throws com.liferay.portal.kernel.exception.SystemException { 416 return getPersistence().findByA_R(active, recommended); 417 } 418 419 /** 420 * Returns a range of all the s c licenses where active = ? and recommended = ?. 421 * 422 * <p> 423 * 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. 424 * </p> 425 * 426 * @param active the active 427 * @param recommended the recommended 428 * @param start the lower bound of the range of s c licenses 429 * @param end the upper bound of the range of s c licenses (not inclusive) 430 * @return the range of matching s c licenses 431 * @throws SystemException if a system exception occurred 432 */ 433 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByA_R( 434 boolean active, boolean recommended, int start, int end) 435 throws com.liferay.portal.kernel.exception.SystemException { 436 return getPersistence().findByA_R(active, recommended, start, end); 437 } 438 439 /** 440 * Returns an ordered range of all the s c licenses where active = ? and recommended = ?. 441 * 442 * <p> 443 * 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. 444 * </p> 445 * 446 * @param active the active 447 * @param recommended the recommended 448 * @param start the lower bound of the range of s c licenses 449 * @param end the upper bound of the range of s c licenses (not inclusive) 450 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 451 * @return the ordered range of matching s c licenses 452 * @throws SystemException if a system exception occurred 453 */ 454 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByA_R( 455 boolean active, boolean recommended, int start, int end, 456 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 457 throws com.liferay.portal.kernel.exception.SystemException { 458 return getPersistence() 459 .findByA_R(active, recommended, start, end, orderByComparator); 460 } 461 462 /** 463 * Returns the first s c license in the ordered set where active = ? and recommended = ?. 464 * 465 * @param active the active 466 * @param recommended the recommended 467 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 468 * @return the first matching s c license 469 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a matching s c license could not be found 470 * @throws SystemException if a system exception occurred 471 */ 472 public static com.liferay.portlet.softwarecatalog.model.SCLicense findByA_R_First( 473 boolean active, boolean recommended, 474 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 475 throws com.liferay.portal.kernel.exception.SystemException, 476 com.liferay.portlet.softwarecatalog.NoSuchLicenseException { 477 return getPersistence() 478 .findByA_R_First(active, recommended, orderByComparator); 479 } 480 481 /** 482 * Returns the first s c license in the ordered set where active = ? and recommended = ?. 483 * 484 * @param active the active 485 * @param recommended the recommended 486 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 487 * @return the first matching s c license, or <code>null</code> if a matching s c license could not be found 488 * @throws SystemException if a system exception occurred 489 */ 490 public static com.liferay.portlet.softwarecatalog.model.SCLicense fetchByA_R_First( 491 boolean active, boolean recommended, 492 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 493 throws com.liferay.portal.kernel.exception.SystemException { 494 return getPersistence() 495 .fetchByA_R_First(active, recommended, orderByComparator); 496 } 497 498 /** 499 * Returns the last s c license in the ordered set where active = ? and recommended = ?. 500 * 501 * @param active the active 502 * @param recommended the recommended 503 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 504 * @return the last matching s c license 505 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a matching s c license could not be found 506 * @throws SystemException if a system exception occurred 507 */ 508 public static com.liferay.portlet.softwarecatalog.model.SCLicense findByA_R_Last( 509 boolean active, boolean recommended, 510 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 511 throws com.liferay.portal.kernel.exception.SystemException, 512 com.liferay.portlet.softwarecatalog.NoSuchLicenseException { 513 return getPersistence() 514 .findByA_R_Last(active, recommended, orderByComparator); 515 } 516 517 /** 518 * Returns the last s c license in the ordered set where active = ? and recommended = ?. 519 * 520 * @param active the active 521 * @param recommended the recommended 522 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 523 * @return the last matching s c license, or <code>null</code> if a matching s c license could not be found 524 * @throws SystemException if a system exception occurred 525 */ 526 public static com.liferay.portlet.softwarecatalog.model.SCLicense fetchByA_R_Last( 527 boolean active, boolean recommended, 528 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 529 throws com.liferay.portal.kernel.exception.SystemException { 530 return getPersistence() 531 .fetchByA_R_Last(active, recommended, orderByComparator); 532 } 533 534 /** 535 * Returns the s c licenses before and after the current s c license in the ordered set where active = ? and recommended = ?. 536 * 537 * @param licenseId the primary key of the current s c license 538 * @param active the active 539 * @param recommended the recommended 540 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 541 * @return the previous, current, and next s c license 542 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found 543 * @throws SystemException if a system exception occurred 544 */ 545 public static com.liferay.portlet.softwarecatalog.model.SCLicense[] findByA_R_PrevAndNext( 546 long licenseId, boolean active, boolean recommended, 547 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 548 throws com.liferay.portal.kernel.exception.SystemException, 549 com.liferay.portlet.softwarecatalog.NoSuchLicenseException { 550 return getPersistence() 551 .findByA_R_PrevAndNext(licenseId, active, recommended, 552 orderByComparator); 553 } 554 555 /** 556 * Returns all the s c licenses that the user has permission to view where active = ? and recommended = ?. 557 * 558 * @param active the active 559 * @param recommended the recommended 560 * @return the matching s c licenses that the user has permission to view 561 * @throws SystemException if a system exception occurred 562 */ 563 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByA_R( 564 boolean active, boolean recommended) 565 throws com.liferay.portal.kernel.exception.SystemException { 566 return getPersistence().filterFindByA_R(active, recommended); 567 } 568 569 /** 570 * Returns a range of all the s c licenses that the user has permission to view where active = ? and recommended = ?. 571 * 572 * <p> 573 * 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. 574 * </p> 575 * 576 * @param active the active 577 * @param recommended the recommended 578 * @param start the lower bound of the range of s c licenses 579 * @param end the upper bound of the range of s c licenses (not inclusive) 580 * @return the range of matching s c licenses that the user has permission to view 581 * @throws SystemException if a system exception occurred 582 */ 583 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByA_R( 584 boolean active, boolean recommended, int start, int end) 585 throws com.liferay.portal.kernel.exception.SystemException { 586 return getPersistence().filterFindByA_R(active, recommended, start, end); 587 } 588 589 /** 590 * Returns an ordered range of all the s c licenses that the user has permissions to view where active = ? and recommended = ?. 591 * 592 * <p> 593 * 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. 594 * </p> 595 * 596 * @param active the active 597 * @param recommended the recommended 598 * @param start the lower bound of the range of s c licenses 599 * @param end the upper bound of the range of s c licenses (not inclusive) 600 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 601 * @return the ordered range of matching s c licenses that the user has permission to view 602 * @throws SystemException if a system exception occurred 603 */ 604 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByA_R( 605 boolean active, boolean recommended, int start, int end, 606 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 607 throws com.liferay.portal.kernel.exception.SystemException { 608 return getPersistence() 609 .filterFindByA_R(active, recommended, start, end, 610 orderByComparator); 611 } 612 613 /** 614 * Returns the s c licenses before and after the current s c license in the ordered set of s c licenses that the user has permission to view where active = ? and recommended = ?. 615 * 616 * @param licenseId the primary key of the current s c license 617 * @param active the active 618 * @param recommended the recommended 619 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 620 * @return the previous, current, and next s c license 621 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found 622 * @throws SystemException if a system exception occurred 623 */ 624 public static com.liferay.portlet.softwarecatalog.model.SCLicense[] filterFindByA_R_PrevAndNext( 625 long licenseId, boolean active, boolean recommended, 626 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 627 throws com.liferay.portal.kernel.exception.SystemException, 628 com.liferay.portlet.softwarecatalog.NoSuchLicenseException { 629 return getPersistence() 630 .filterFindByA_R_PrevAndNext(licenseId, active, recommended, 631 orderByComparator); 632 } 633 634 /** 635 * Returns all the s c licenses. 636 * 637 * @return the s c licenses 638 * @throws SystemException if a system exception occurred 639 */ 640 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findAll() 641 throws com.liferay.portal.kernel.exception.SystemException { 642 return getPersistence().findAll(); 643 } 644 645 /** 646 * Returns a range of all the s c licenses. 647 * 648 * <p> 649 * 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. 650 * </p> 651 * 652 * @param start the lower bound of the range of s c licenses 653 * @param end the upper bound of the range of s c licenses (not inclusive) 654 * @return the range of s c licenses 655 * @throws SystemException if a system exception occurred 656 */ 657 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findAll( 658 int start, int end) 659 throws com.liferay.portal.kernel.exception.SystemException { 660 return getPersistence().findAll(start, end); 661 } 662 663 /** 664 * Returns an ordered range of all the s c licenses. 665 * 666 * <p> 667 * 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. 668 * </p> 669 * 670 * @param start the lower bound of the range of s c licenses 671 * @param end the upper bound of the range of s c licenses (not inclusive) 672 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 673 * @return the ordered range of s c licenses 674 * @throws SystemException if a system exception occurred 675 */ 676 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findAll( 677 int start, int end, 678 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 679 throws com.liferay.portal.kernel.exception.SystemException { 680 return getPersistence().findAll(start, end, orderByComparator); 681 } 682 683 /** 684 * Removes all the s c licenses where active = ? from the database. 685 * 686 * @param active the active 687 * @throws SystemException if a system exception occurred 688 */ 689 public static void removeByActive(boolean active) 690 throws com.liferay.portal.kernel.exception.SystemException { 691 getPersistence().removeByActive(active); 692 } 693 694 /** 695 * Removes all the s c licenses where active = ? and recommended = ? from the database. 696 * 697 * @param active the active 698 * @param recommended the recommended 699 * @throws SystemException if a system exception occurred 700 */ 701 public static void removeByA_R(boolean active, boolean recommended) 702 throws com.liferay.portal.kernel.exception.SystemException { 703 getPersistence().removeByA_R(active, recommended); 704 } 705 706 /** 707 * Removes all the s c licenses from the database. 708 * 709 * @throws SystemException if a system exception occurred 710 */ 711 public static void removeAll() 712 throws com.liferay.portal.kernel.exception.SystemException { 713 getPersistence().removeAll(); 714 } 715 716 /** 717 * Returns the number of s c licenses where active = ?. 718 * 719 * @param active the active 720 * @return the number of matching s c licenses 721 * @throws SystemException if a system exception occurred 722 */ 723 public static int countByActive(boolean active) 724 throws com.liferay.portal.kernel.exception.SystemException { 725 return getPersistence().countByActive(active); 726 } 727 728 /** 729 * Returns the number of s c licenses that the user has permission to view where active = ?. 730 * 731 * @param active the active 732 * @return the number of matching s c licenses that the user has permission to view 733 * @throws SystemException if a system exception occurred 734 */ 735 public static int filterCountByActive(boolean active) 736 throws com.liferay.portal.kernel.exception.SystemException { 737 return getPersistence().filterCountByActive(active); 738 } 739 740 /** 741 * Returns the number of s c licenses where active = ? and recommended = ?. 742 * 743 * @param active the active 744 * @param recommended the recommended 745 * @return the number of matching s c licenses 746 * @throws SystemException if a system exception occurred 747 */ 748 public static int countByA_R(boolean active, boolean recommended) 749 throws com.liferay.portal.kernel.exception.SystemException { 750 return getPersistence().countByA_R(active, recommended); 751 } 752 753 /** 754 * Returns the number of s c licenses that the user has permission to view where active = ? and recommended = ?. 755 * 756 * @param active the active 757 * @param recommended the recommended 758 * @return the number of matching s c licenses that the user has permission to view 759 * @throws SystemException if a system exception occurred 760 */ 761 public static int filterCountByA_R(boolean active, boolean recommended) 762 throws com.liferay.portal.kernel.exception.SystemException { 763 return getPersistence().filterCountByA_R(active, recommended); 764 } 765 766 /** 767 * Returns the number of s c licenses. 768 * 769 * @return the number of s c licenses 770 * @throws SystemException if a system exception occurred 771 */ 772 public static int countAll() 773 throws com.liferay.portal.kernel.exception.SystemException { 774 return getPersistence().countAll(); 775 } 776 777 /** 778 * Returns all the s c product entries associated with the s c license. 779 * 780 * @param pk the primary key of the s c license 781 * @return the s c product entries associated with the s c license 782 * @throws SystemException if a system exception occurred 783 */ 784 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> getSCProductEntries( 785 long pk) throws com.liferay.portal.kernel.exception.SystemException { 786 return getPersistence().getSCProductEntries(pk); 787 } 788 789 /** 790 * Returns a range of all the s c product entries associated with the s c license. 791 * 792 * <p> 793 * 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. 794 * </p> 795 * 796 * @param pk the primary key of the s c license 797 * @param start the lower bound of the range of s c licenses 798 * @param end the upper bound of the range of s c licenses (not inclusive) 799 * @return the range of s c product entries associated with the s c license 800 * @throws SystemException if a system exception occurred 801 */ 802 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> getSCProductEntries( 803 long pk, int start, int end) 804 throws com.liferay.portal.kernel.exception.SystemException { 805 return getPersistence().getSCProductEntries(pk, start, end); 806 } 807 808 /** 809 * Returns an ordered range of all the s c product entries associated with the s c license. 810 * 811 * <p> 812 * 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. 813 * </p> 814 * 815 * @param pk the primary key of the s c license 816 * @param start the lower bound of the range of s c licenses 817 * @param end the upper bound of the range of s c licenses (not inclusive) 818 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 819 * @return the ordered range of s c product entries associated with the s c license 820 * @throws SystemException if a system exception occurred 821 */ 822 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> getSCProductEntries( 823 long pk, int start, int end, 824 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 825 throws com.liferay.portal.kernel.exception.SystemException { 826 return getPersistence() 827 .getSCProductEntries(pk, start, end, orderByComparator); 828 } 829 830 /** 831 * Returns the number of s c product entries associated with the s c license. 832 * 833 * @param pk the primary key of the s c license 834 * @return the number of s c product entries associated with the s c license 835 * @throws SystemException if a system exception occurred 836 */ 837 public static int getSCProductEntriesSize(long pk) 838 throws com.liferay.portal.kernel.exception.SystemException { 839 return getPersistence().getSCProductEntriesSize(pk); 840 } 841 842 /** 843 * Returns <code>true</code> if the s c product entry is associated with the s c license. 844 * 845 * @param pk the primary key of the s c license 846 * @param scProductEntryPK the primary key of the s c product entry 847 * @return <code>true</code> if the s c product entry is associated with the s c license; <code>false</code> otherwise 848 * @throws SystemException if a system exception occurred 849 */ 850 public static boolean containsSCProductEntry(long pk, long scProductEntryPK) 851 throws com.liferay.portal.kernel.exception.SystemException { 852 return getPersistence().containsSCProductEntry(pk, scProductEntryPK); 853 } 854 855 /** 856 * Returns <code>true</code> if the s c license has any s c product entries associated with it. 857 * 858 * @param pk the primary key of the s c license to check for associations with s c product entries 859 * @return <code>true</code> if the s c license has any s c product entries associated with it; <code>false</code> otherwise 860 * @throws SystemException if a system exception occurred 861 */ 862 public static boolean containsSCProductEntries(long pk) 863 throws com.liferay.portal.kernel.exception.SystemException { 864 return getPersistence().containsSCProductEntries(pk); 865 } 866 867 /** 868 * Adds an association between the s c license and the s c product entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 869 * 870 * @param pk the primary key of the s c license 871 * @param scProductEntryPK the primary key of the s c product entry 872 * @throws SystemException if a system exception occurred 873 */ 874 public static void addSCProductEntry(long pk, long scProductEntryPK) 875 throws com.liferay.portal.kernel.exception.SystemException { 876 getPersistence().addSCProductEntry(pk, scProductEntryPK); 877 } 878 879 /** 880 * Adds an association between the s c license and the s c product entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 881 * 882 * @param pk the primary key of the s c license 883 * @param scProductEntry the s c product entry 884 * @throws SystemException if a system exception occurred 885 */ 886 public static void addSCProductEntry(long pk, 887 com.liferay.portlet.softwarecatalog.model.SCProductEntry scProductEntry) 888 throws com.liferay.portal.kernel.exception.SystemException { 889 getPersistence().addSCProductEntry(pk, scProductEntry); 890 } 891 892 /** 893 * Adds an association between the s c license and the s c product entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 894 * 895 * @param pk the primary key of the s c license 896 * @param scProductEntryPKs the primary keys of the s c product entries 897 * @throws SystemException if a system exception occurred 898 */ 899 public static void addSCProductEntries(long pk, long[] scProductEntryPKs) 900 throws com.liferay.portal.kernel.exception.SystemException { 901 getPersistence().addSCProductEntries(pk, scProductEntryPKs); 902 } 903 904 /** 905 * Adds an association between the s c license and the s c product entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 906 * 907 * @param pk the primary key of the s c license 908 * @param scProductEntries the s c product entries 909 * @throws SystemException if a system exception occurred 910 */ 911 public static void addSCProductEntries(long pk, 912 java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> scProductEntries) 913 throws com.liferay.portal.kernel.exception.SystemException { 914 getPersistence().addSCProductEntries(pk, scProductEntries); 915 } 916 917 /** 918 * Clears all associations between the s c license and its s c product entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 919 * 920 * @param pk the primary key of the s c license to clear the associated s c product entries from 921 * @throws SystemException if a system exception occurred 922 */ 923 public static void clearSCProductEntries(long pk) 924 throws com.liferay.portal.kernel.exception.SystemException { 925 getPersistence().clearSCProductEntries(pk); 926 } 927 928 /** 929 * Removes the association between the s c license and the s c product entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 930 * 931 * @param pk the primary key of the s c license 932 * @param scProductEntryPK the primary key of the s c product entry 933 * @throws SystemException if a system exception occurred 934 */ 935 public static void removeSCProductEntry(long pk, long scProductEntryPK) 936 throws com.liferay.portal.kernel.exception.SystemException { 937 getPersistence().removeSCProductEntry(pk, scProductEntryPK); 938 } 939 940 /** 941 * Removes the association between the s c license and the s c product entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 942 * 943 * @param pk the primary key of the s c license 944 * @param scProductEntry the s c product entry 945 * @throws SystemException if a system exception occurred 946 */ 947 public static void removeSCProductEntry(long pk, 948 com.liferay.portlet.softwarecatalog.model.SCProductEntry scProductEntry) 949 throws com.liferay.portal.kernel.exception.SystemException { 950 getPersistence().removeSCProductEntry(pk, scProductEntry); 951 } 952 953 /** 954 * Removes the association between the s c license and the s c product entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 955 * 956 * @param pk the primary key of the s c license 957 * @param scProductEntryPKs the primary keys of the s c product entries 958 * @throws SystemException if a system exception occurred 959 */ 960 public static void removeSCProductEntries(long pk, long[] scProductEntryPKs) 961 throws com.liferay.portal.kernel.exception.SystemException { 962 getPersistence().removeSCProductEntries(pk, scProductEntryPKs); 963 } 964 965 /** 966 * Removes the association between the s c license and the s c product entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 967 * 968 * @param pk the primary key of the s c license 969 * @param scProductEntries the s c product entries 970 * @throws SystemException if a system exception occurred 971 */ 972 public static void removeSCProductEntries(long pk, 973 java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> scProductEntries) 974 throws com.liferay.portal.kernel.exception.SystemException { 975 getPersistence().removeSCProductEntries(pk, scProductEntries); 976 } 977 978 /** 979 * Sets the s c product entries associated with the s c license, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 980 * 981 * @param pk the primary key of the s c license 982 * @param scProductEntryPKs the primary keys of the s c product entries to be associated with the s c license 983 * @throws SystemException if a system exception occurred 984 */ 985 public static void setSCProductEntries(long pk, long[] scProductEntryPKs) 986 throws com.liferay.portal.kernel.exception.SystemException { 987 getPersistence().setSCProductEntries(pk, scProductEntryPKs); 988 } 989 990 /** 991 * Sets the s c product entries associated with the s c license, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 992 * 993 * @param pk the primary key of the s c license 994 * @param scProductEntries the s c product entries to be associated with the s c license 995 * @throws SystemException if a system exception occurred 996 */ 997 public static void setSCProductEntries(long pk, 998 java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> scProductEntries) 999 throws com.liferay.portal.kernel.exception.SystemException { 1000 getPersistence().setSCProductEntries(pk, scProductEntries); 1001 } 1002 1003 public static SCLicensePersistence getPersistence() { 1004 if (_persistence == null) { 1005 _persistence = (SCLicensePersistence)PortalBeanLocatorUtil.locate(SCLicensePersistence.class.getName()); 1006 1007 ReferenceRegistry.registerReference(SCLicenseUtil.class, 1008 "_persistence"); 1009 } 1010 1011 return _persistence; 1012 } 1013 1014 /** 1015 * @deprecated 1016 */ 1017 public void setPersistence(SCLicensePersistence persistence) { 1018 } 1019 1020 private static SCLicensePersistence _persistence; 1021 }