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