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