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