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