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