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