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