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 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 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 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 * 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. 176 * 177 * @param productEntryId the primary key of the s c product entry 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 * Returns 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 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 * Returns all the s c product entries where groupId = ?. 204 * 205 * @param groupId the group ID 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 * Returns 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 223 * @param start the lower bound of the range of s c product entries 224 * @param end the upper bound of the range of s c product entries (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 * Returns 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 242 * @param start the lower bound of the range of s c product entries 243 * @param end the upper bound of the range of s c product entries (not inclusive) 244 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 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 * Returns 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 264 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 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 * Returns 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 285 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 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 * Returns 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 307 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 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 * Returns all the s c product entries that the user has permission to view where groupId = ?. 324 * 325 * @param groupId the group ID 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 * Returns a range of all the s c product entries that the user has permission to view 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 343 * @param start the lower bound of the range of s c product entries 344 * @param end the upper bound of the range of s c product entries (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 * Returns an ordered range of all the s c product entries that the user has permissions to view 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 362 * @param start the lower bound of the range of s c product entries 363 * @param end the upper bound of the range of s c product entries (not inclusive) 364 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 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 * 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 = ?. 378 * 379 * @param productEntryId the primary key of the current s c product entry 380 * @param groupId the group ID 381 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 382 * @return the previous, current, and next s c product entry 383 * @throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException if a s c product entry with the primary key could not be found 384 * @throws SystemException if a system exception occurred 385 */ 386 public static com.liferay.portlet.softwarecatalog.model.SCProductEntry[] filterFindByGroupId_PrevAndNext( 387 long productEntryId, long groupId, 388 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 389 throws com.liferay.portal.kernel.exception.SystemException, 390 com.liferay.portlet.softwarecatalog.NoSuchProductEntryException { 391 return getPersistence() 392 .filterFindByGroupId_PrevAndNext(productEntryId, groupId, 393 orderByComparator); 394 } 395 396 /** 397 * Returns all the s c product entries where companyId = ?. 398 * 399 * @param companyId the company ID 400 * @return the matching s c product entries 401 * @throws SystemException if a system exception occurred 402 */ 403 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> findByCompanyId( 404 long companyId) 405 throws com.liferay.portal.kernel.exception.SystemException { 406 return getPersistence().findByCompanyId(companyId); 407 } 408 409 /** 410 * Returns a range of all the s c product entries where companyId = ?. 411 * 412 * <p> 413 * 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. 414 * </p> 415 * 416 * @param companyId the company ID 417 * @param start the lower bound of the range of s c product entries 418 * @param end the upper bound of the range of s c product entries (not inclusive) 419 * @return the range of matching s c product entries 420 * @throws SystemException if a system exception occurred 421 */ 422 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> findByCompanyId( 423 long companyId, int start, int end) 424 throws com.liferay.portal.kernel.exception.SystemException { 425 return getPersistence().findByCompanyId(companyId, start, end); 426 } 427 428 /** 429 * Returns an ordered range of all the s c product entries where companyId = ?. 430 * 431 * <p> 432 * 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. 433 * </p> 434 * 435 * @param companyId the company ID 436 * @param start the lower bound of the range of s c product entries 437 * @param end the upper bound of the range of s c product entries (not inclusive) 438 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 439 * @return the ordered range of matching s c product entries 440 * @throws SystemException if a system exception occurred 441 */ 442 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> findByCompanyId( 443 long companyId, int start, int end, 444 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 445 throws com.liferay.portal.kernel.exception.SystemException { 446 return getPersistence() 447 .findByCompanyId(companyId, start, end, orderByComparator); 448 } 449 450 /** 451 * Returns the first s c product entry in the ordered set where companyId = ?. 452 * 453 * <p> 454 * 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. 455 * </p> 456 * 457 * @param companyId the company ID 458 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 459 * @return the first matching s c product entry 460 * @throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException if a matching s c product entry could not be found 461 * @throws SystemException if a system exception occurred 462 */ 463 public static com.liferay.portlet.softwarecatalog.model.SCProductEntry findByCompanyId_First( 464 long companyId, 465 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 466 throws com.liferay.portal.kernel.exception.SystemException, 467 com.liferay.portlet.softwarecatalog.NoSuchProductEntryException { 468 return getPersistence() 469 .findByCompanyId_First(companyId, orderByComparator); 470 } 471 472 /** 473 * Returns the last s c product entry in the ordered set where companyId = ?. 474 * 475 * <p> 476 * 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. 477 * </p> 478 * 479 * @param companyId the company ID 480 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 481 * @return the last matching s c product entry 482 * @throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException 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 findByCompanyId_Last( 486 long companyId, 487 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 488 throws com.liferay.portal.kernel.exception.SystemException, 489 com.liferay.portlet.softwarecatalog.NoSuchProductEntryException { 490 return getPersistence() 491 .findByCompanyId_Last(companyId, orderByComparator); 492 } 493 494 /** 495 * Returns the s c product entries before and after the current s c product entry in the ordered set where companyId = ?. 496 * 497 * <p> 498 * 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. 499 * </p> 500 * 501 * @param productEntryId the primary key of the current s c product entry 502 * @param companyId the company ID 503 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 504 * @return the previous, current, and next s c product entry 505 * @throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException if a s c product entry with the primary key could not be found 506 * @throws SystemException if a system exception occurred 507 */ 508 public static com.liferay.portlet.softwarecatalog.model.SCProductEntry[] findByCompanyId_PrevAndNext( 509 long productEntryId, long companyId, 510 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 511 throws com.liferay.portal.kernel.exception.SystemException, 512 com.liferay.portlet.softwarecatalog.NoSuchProductEntryException { 513 return getPersistence() 514 .findByCompanyId_PrevAndNext(productEntryId, companyId, 515 orderByComparator); 516 } 517 518 /** 519 * Returns all the s c product entries where groupId = ? and userId = ?. 520 * 521 * @param groupId the group ID 522 * @param userId the user ID 523 * @return the matching s c product entries 524 * @throws SystemException if a system exception occurred 525 */ 526 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> findByG_U( 527 long groupId, long userId) 528 throws com.liferay.portal.kernel.exception.SystemException { 529 return getPersistence().findByG_U(groupId, userId); 530 } 531 532 /** 533 * Returns a range of all the s c product entries where groupId = ? and userId = ?. 534 * 535 * <p> 536 * 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. 537 * </p> 538 * 539 * @param groupId the group ID 540 * @param userId the user ID 541 * @param start the lower bound of the range of s c product entries 542 * @param end the upper bound of the range of s c product entries (not inclusive) 543 * @return the range of matching s c product entries 544 * @throws SystemException if a system exception occurred 545 */ 546 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> findByG_U( 547 long groupId, long userId, int start, int end) 548 throws com.liferay.portal.kernel.exception.SystemException { 549 return getPersistence().findByG_U(groupId, userId, start, end); 550 } 551 552 /** 553 * Returns an ordered range of all the s c product entries where groupId = ? and userId = ?. 554 * 555 * <p> 556 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 557 * </p> 558 * 559 * @param groupId the group ID 560 * @param userId the user ID 561 * @param start the lower bound of the range of s c product entries 562 * @param end the upper bound of the range of s c product entries (not inclusive) 563 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 564 * @return the ordered range of matching s c product entries 565 * @throws SystemException if a system exception occurred 566 */ 567 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> findByG_U( 568 long groupId, long userId, int start, int end, 569 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 570 throws com.liferay.portal.kernel.exception.SystemException { 571 return getPersistence() 572 .findByG_U(groupId, userId, start, end, orderByComparator); 573 } 574 575 /** 576 * Returns the first s c product entry in the ordered set where groupId = ? and userId = ?. 577 * 578 * <p> 579 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 580 * </p> 581 * 582 * @param groupId the group ID 583 * @param userId the user ID 584 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 585 * @return the first matching s c product entry 586 * @throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException if a matching s c product entry could not be found 587 * @throws SystemException if a system exception occurred 588 */ 589 public static com.liferay.portlet.softwarecatalog.model.SCProductEntry findByG_U_First( 590 long groupId, long userId, 591 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 592 throws com.liferay.portal.kernel.exception.SystemException, 593 com.liferay.portlet.softwarecatalog.NoSuchProductEntryException { 594 return getPersistence() 595 .findByG_U_First(groupId, userId, orderByComparator); 596 } 597 598 /** 599 * Returns the last s c product entry in the ordered set where groupId = ? and userId = ?. 600 * 601 * <p> 602 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. 603 * </p> 604 * 605 * @param groupId the group ID 606 * @param userId the user ID 607 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 608 * @return the last matching s c product entry 609 * @throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException if a matching s c product entry could not be found 610 * @throws SystemException if a system exception occurred 611 */ 612 public static com.liferay.portlet.softwarecatalog.model.SCProductEntry findByG_U_Last( 613 long groupId, long userId, 614 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 615 throws com.liferay.portal.kernel.exception.SystemException, 616 com.liferay.portlet.softwarecatalog.NoSuchProductEntryException { 617 return getPersistence() 618 .findByG_U_Last(groupId, userId, orderByComparator); 619 } 620 621 /** 622 * Returns the s c product entries before and after the current s c product entry in the ordered set where groupId = ? and userId = ?. 623 * 624 * <p> 625 * 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. 626 * </p> 627 * 628 * @param productEntryId the primary key of the current s c product entry 629 * @param groupId the group ID 630 * @param userId the user ID 631 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 632 * @return the previous, current, and next s c product entry 633 * @throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException if a s c product entry with the primary key could not be found 634 * @throws SystemException if a system exception occurred 635 */ 636 public static com.liferay.portlet.softwarecatalog.model.SCProductEntry[] findByG_U_PrevAndNext( 637 long productEntryId, long groupId, long userId, 638 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 639 throws com.liferay.portal.kernel.exception.SystemException, 640 com.liferay.portlet.softwarecatalog.NoSuchProductEntryException { 641 return getPersistence() 642 .findByG_U_PrevAndNext(productEntryId, groupId, userId, 643 orderByComparator); 644 } 645 646 /** 647 * Returns all the s c product entries that the user has permission to view where groupId = ? and userId = ?. 648 * 649 * @param groupId the group ID 650 * @param userId the user ID 651 * @return the matching s c product entries that the user has permission to view 652 * @throws SystemException if a system exception occurred 653 */ 654 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> filterFindByG_U( 655 long groupId, long userId) 656 throws com.liferay.portal.kernel.exception.SystemException { 657 return getPersistence().filterFindByG_U(groupId, userId); 658 } 659 660 /** 661 * Returns a range of all the s c product entries that the user has permission to view where groupId = ? and userId = ?. 662 * 663 * <p> 664 * 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. 665 * </p> 666 * 667 * @param groupId the group ID 668 * @param userId the user ID 669 * @param start the lower bound of the range of s c product entries 670 * @param end the upper bound of the range of s c product entries (not inclusive) 671 * @return the range of matching s c product entries that the user has permission to view 672 * @throws SystemException if a system exception occurred 673 */ 674 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> filterFindByG_U( 675 long groupId, long userId, int start, int end) 676 throws com.liferay.portal.kernel.exception.SystemException { 677 return getPersistence().filterFindByG_U(groupId, userId, start, end); 678 } 679 680 /** 681 * Returns an ordered range of all the s c product entries that the user has permissions to view where groupId = ? and userId = ?. 682 * 683 * <p> 684 * 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. 685 * </p> 686 * 687 * @param groupId the group ID 688 * @param userId the user ID 689 * @param start the lower bound of the range of s c product entries 690 * @param end the upper bound of the range of s c product entries (not inclusive) 691 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 692 * @return the ordered range of matching s c product entries that the user has permission to view 693 * @throws SystemException if a system exception occurred 694 */ 695 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> filterFindByG_U( 696 long groupId, long userId, int start, int end, 697 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 698 throws com.liferay.portal.kernel.exception.SystemException { 699 return getPersistence() 700 .filterFindByG_U(groupId, userId, start, end, 701 orderByComparator); 702 } 703 704 /** 705 * 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 = ?. 706 * 707 * @param productEntryId the primary key of the current s c product entry 708 * @param groupId the group ID 709 * @param userId the user ID 710 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 711 * @return the previous, current, and next s c product entry 712 * @throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException if a s c product entry with the primary key could not be found 713 * @throws SystemException if a system exception occurred 714 */ 715 public static com.liferay.portlet.softwarecatalog.model.SCProductEntry[] filterFindByG_U_PrevAndNext( 716 long productEntryId, long groupId, long userId, 717 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 718 throws com.liferay.portal.kernel.exception.SystemException, 719 com.liferay.portlet.softwarecatalog.NoSuchProductEntryException { 720 return getPersistence() 721 .filterFindByG_U_PrevAndNext(productEntryId, groupId, 722 userId, orderByComparator); 723 } 724 725 /** 726 * 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. 727 * 728 * @param repoGroupId the repo group ID 729 * @param repoArtifactId the repo artifact ID 730 * @return the matching s c product entry 731 * @throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException if a matching s c product entry could not be found 732 * @throws SystemException if a system exception occurred 733 */ 734 public static com.liferay.portlet.softwarecatalog.model.SCProductEntry findByRG_RA( 735 java.lang.String repoGroupId, java.lang.String repoArtifactId) 736 throws com.liferay.portal.kernel.exception.SystemException, 737 com.liferay.portlet.softwarecatalog.NoSuchProductEntryException { 738 return getPersistence().findByRG_RA(repoGroupId, repoArtifactId); 739 } 740 741 /** 742 * 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. 743 * 744 * @param repoGroupId the repo group ID 745 * @param repoArtifactId the repo artifact ID 746 * @return the matching s c product entry, or <code>null</code> if a matching s c product entry could not be found 747 * @throws SystemException if a system exception occurred 748 */ 749 public static com.liferay.portlet.softwarecatalog.model.SCProductEntry fetchByRG_RA( 750 java.lang.String repoGroupId, java.lang.String repoArtifactId) 751 throws com.liferay.portal.kernel.exception.SystemException { 752 return getPersistence().fetchByRG_RA(repoGroupId, repoArtifactId); 753 } 754 755 /** 756 * 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. 757 * 758 * @param repoGroupId the repo group ID 759 * @param repoArtifactId the repo artifact ID 760 * @param retrieveFromCache whether to use the finder cache 761 * @return the matching s c product entry, or <code>null</code> if a matching s c product entry could not be found 762 * @throws SystemException if a system exception occurred 763 */ 764 public static com.liferay.portlet.softwarecatalog.model.SCProductEntry fetchByRG_RA( 765 java.lang.String repoGroupId, java.lang.String repoArtifactId, 766 boolean retrieveFromCache) 767 throws com.liferay.portal.kernel.exception.SystemException { 768 return getPersistence() 769 .fetchByRG_RA(repoGroupId, repoArtifactId, retrieveFromCache); 770 } 771 772 /** 773 * Returns all the s c product entries. 774 * 775 * @return the s c product entries 776 * @throws SystemException if a system exception occurred 777 */ 778 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> findAll() 779 throws com.liferay.portal.kernel.exception.SystemException { 780 return getPersistence().findAll(); 781 } 782 783 /** 784 * Returns a range of all the s c product entries. 785 * 786 * <p> 787 * 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. 788 * </p> 789 * 790 * @param start the lower bound of the range of s c product entries 791 * @param end the upper bound of the range of s c product entries (not inclusive) 792 * @return the range of s c product entries 793 * @throws SystemException if a system exception occurred 794 */ 795 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> findAll( 796 int start, int end) 797 throws com.liferay.portal.kernel.exception.SystemException { 798 return getPersistence().findAll(start, end); 799 } 800 801 /** 802 * Returns an ordered range of all the s c product entries. 803 * 804 * <p> 805 * 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. 806 * </p> 807 * 808 * @param start the lower bound of the range of s c product entries 809 * @param end the upper bound of the range of s c product entries (not inclusive) 810 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 811 * @return the ordered range of s c product entries 812 * @throws SystemException if a system exception occurred 813 */ 814 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> findAll( 815 int start, int end, 816 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 817 throws com.liferay.portal.kernel.exception.SystemException { 818 return getPersistence().findAll(start, end, orderByComparator); 819 } 820 821 /** 822 * Removes all the s c product entries where groupId = ? from the database. 823 * 824 * @param groupId the group ID 825 * @throws SystemException if a system exception occurred 826 */ 827 public static void removeByGroupId(long groupId) 828 throws com.liferay.portal.kernel.exception.SystemException { 829 getPersistence().removeByGroupId(groupId); 830 } 831 832 /** 833 * Removes all the s c product entries where companyId = ? from the database. 834 * 835 * @param companyId the company ID 836 * @throws SystemException if a system exception occurred 837 */ 838 public static void removeByCompanyId(long companyId) 839 throws com.liferay.portal.kernel.exception.SystemException { 840 getPersistence().removeByCompanyId(companyId); 841 } 842 843 /** 844 * Removes all the s c product entries where groupId = ? and userId = ? from the database. 845 * 846 * @param groupId the group ID 847 * @param userId the user ID 848 * @throws SystemException if a system exception occurred 849 */ 850 public static void removeByG_U(long groupId, long userId) 851 throws com.liferay.portal.kernel.exception.SystemException { 852 getPersistence().removeByG_U(groupId, userId); 853 } 854 855 /** 856 * Removes the s c product entry where repoGroupId = ? and repoArtifactId = ? from the database. 857 * 858 * @param repoGroupId the repo group ID 859 * @param repoArtifactId the repo artifact ID 860 * @throws SystemException if a system exception occurred 861 */ 862 public static void removeByRG_RA(java.lang.String repoGroupId, 863 java.lang.String repoArtifactId) 864 throws com.liferay.portal.kernel.exception.SystemException, 865 com.liferay.portlet.softwarecatalog.NoSuchProductEntryException { 866 getPersistence().removeByRG_RA(repoGroupId, repoArtifactId); 867 } 868 869 /** 870 * Removes all the s c product entries from the database. 871 * 872 * @throws SystemException if a system exception occurred 873 */ 874 public static void removeAll() 875 throws com.liferay.portal.kernel.exception.SystemException { 876 getPersistence().removeAll(); 877 } 878 879 /** 880 * Returns the number of s c product entries where groupId = ?. 881 * 882 * @param groupId the group ID 883 * @return the number of matching s c product entries 884 * @throws SystemException if a system exception occurred 885 */ 886 public static int countByGroupId(long groupId) 887 throws com.liferay.portal.kernel.exception.SystemException { 888 return getPersistence().countByGroupId(groupId); 889 } 890 891 /** 892 * Returns the number of s c product entries that the user has permission to view where groupId = ?. 893 * 894 * @param groupId the group ID 895 * @return the number of matching s c product entries that the user has permission to view 896 * @throws SystemException if a system exception occurred 897 */ 898 public static int filterCountByGroupId(long groupId) 899 throws com.liferay.portal.kernel.exception.SystemException { 900 return getPersistence().filterCountByGroupId(groupId); 901 } 902 903 /** 904 * Returns the number of s c product entries where companyId = ?. 905 * 906 * @param companyId the company ID 907 * @return the number of matching s c product entries 908 * @throws SystemException if a system exception occurred 909 */ 910 public static int countByCompanyId(long companyId) 911 throws com.liferay.portal.kernel.exception.SystemException { 912 return getPersistence().countByCompanyId(companyId); 913 } 914 915 /** 916 * Returns the number of s c product entries where groupId = ? and userId = ?. 917 * 918 * @param groupId the group ID 919 * @param userId the user ID 920 * @return the number of matching s c product entries 921 * @throws SystemException if a system exception occurred 922 */ 923 public static int countByG_U(long groupId, long userId) 924 throws com.liferay.portal.kernel.exception.SystemException { 925 return getPersistence().countByG_U(groupId, userId); 926 } 927 928 /** 929 * Returns the number of s c product entries that the user has permission to view where groupId = ? and userId = ?. 930 * 931 * @param groupId the group ID 932 * @param userId the user ID 933 * @return the number of matching s c product entries that the user has permission to view 934 * @throws SystemException if a system exception occurred 935 */ 936 public static int filterCountByG_U(long groupId, long userId) 937 throws com.liferay.portal.kernel.exception.SystemException { 938 return getPersistence().filterCountByG_U(groupId, userId); 939 } 940 941 /** 942 * Returns the number of s c product entries where repoGroupId = ? and repoArtifactId = ?. 943 * 944 * @param repoGroupId the repo group ID 945 * @param repoArtifactId the repo artifact ID 946 * @return the number of matching s c product entries 947 * @throws SystemException if a system exception occurred 948 */ 949 public static int countByRG_RA(java.lang.String repoGroupId, 950 java.lang.String repoArtifactId) 951 throws com.liferay.portal.kernel.exception.SystemException { 952 return getPersistence().countByRG_RA(repoGroupId, repoArtifactId); 953 } 954 955 /** 956 * Returns the number of s c product entries. 957 * 958 * @return the number of s c product entries 959 * @throws SystemException if a system exception occurred 960 */ 961 public static int countAll() 962 throws com.liferay.portal.kernel.exception.SystemException { 963 return getPersistence().countAll(); 964 } 965 966 /** 967 * Returns all the s c licenses associated with the s c product entry. 968 * 969 * @param pk the primary key of the s c product entry 970 * @return the s c licenses associated with the s c product entry 971 * @throws SystemException if a system exception occurred 972 */ 973 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> getSCLicenses( 974 long pk) throws com.liferay.portal.kernel.exception.SystemException { 975 return getPersistence().getSCLicenses(pk); 976 } 977 978 /** 979 * Returns a range of all the s c licenses associated with the s c product entry. 980 * 981 * <p> 982 * 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. 983 * </p> 984 * 985 * @param pk the primary key of the s c product entry 986 * @param start the lower bound of the range of s c product entries 987 * @param end the upper bound of the range of s c product entries (not inclusive) 988 * @return the range of s c licenses associated with the s c product entry 989 * @throws SystemException if a system exception occurred 990 */ 991 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> getSCLicenses( 992 long pk, int start, int end) 993 throws com.liferay.portal.kernel.exception.SystemException { 994 return getPersistence().getSCLicenses(pk, start, end); 995 } 996 997 /** 998 * Returns an ordered range of all the s c licenses associated with the s c product entry. 999 * 1000 * <p> 1001 * 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. 1002 * </p> 1003 * 1004 * @param pk the primary key of the s c product entry 1005 * @param start the lower bound of the range of s c product entries 1006 * @param end the upper bound of the range of s c product entries (not inclusive) 1007 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1008 * @return the ordered range of s c licenses associated with the s c product entry 1009 * @throws SystemException if a system exception occurred 1010 */ 1011 public static java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> getSCLicenses( 1012 long pk, int start, int end, 1013 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1014 throws com.liferay.portal.kernel.exception.SystemException { 1015 return getPersistence().getSCLicenses(pk, start, end, orderByComparator); 1016 } 1017 1018 /** 1019 * Returns the number of 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 number of s c licenses associated with the s c product entry 1023 * @throws SystemException if a system exception occurred 1024 */ 1025 public static int getSCLicensesSize(long pk) 1026 throws com.liferay.portal.kernel.exception.SystemException { 1027 return getPersistence().getSCLicensesSize(pk); 1028 } 1029 1030 /** 1031 * Returns <code>true</code> if the s c license is associated with the s c product entry. 1032 * 1033 * @param pk the primary key of the s c product entry 1034 * @param scLicensePK the primary key of the s c license 1035 * @return <code>true</code> if the s c license is associated with the s c product entry; <code>false</code> otherwise 1036 * @throws SystemException if a system exception occurred 1037 */ 1038 public static boolean containsSCLicense(long pk, long scLicensePK) 1039 throws com.liferay.portal.kernel.exception.SystemException { 1040 return getPersistence().containsSCLicense(pk, scLicensePK); 1041 } 1042 1043 /** 1044 * Returns <code>true</code> if the s c product entry has any s c licenses associated with it. 1045 * 1046 * @param pk the primary key of the s c product entry to check for associations with s c licenses 1047 * @return <code>true</code> if the s c product entry has any s c licenses associated with it; <code>false</code> otherwise 1048 * @throws SystemException if a system exception occurred 1049 */ 1050 public static boolean containsSCLicenses(long pk) 1051 throws com.liferay.portal.kernel.exception.SystemException { 1052 return getPersistence().containsSCLicenses(pk); 1053 } 1054 1055 /** 1056 * 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. 1057 * 1058 * @param pk the primary key of the s c product entry 1059 * @param scLicensePK the primary key of the s c license 1060 * @throws SystemException if a system exception occurred 1061 */ 1062 public static void addSCLicense(long pk, long scLicensePK) 1063 throws com.liferay.portal.kernel.exception.SystemException { 1064 getPersistence().addSCLicense(pk, scLicensePK); 1065 } 1066 1067 /** 1068 * 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. 1069 * 1070 * @param pk the primary key of the s c product entry 1071 * @param scLicense the s c license 1072 * @throws SystemException if a system exception occurred 1073 */ 1074 public static void addSCLicense(long pk, 1075 com.liferay.portlet.softwarecatalog.model.SCLicense scLicense) 1076 throws com.liferay.portal.kernel.exception.SystemException { 1077 getPersistence().addSCLicense(pk, scLicense); 1078 } 1079 1080 /** 1081 * 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. 1082 * 1083 * @param pk the primary key of the s c product entry 1084 * @param scLicensePKs the primary keys of the s c licenses 1085 * @throws SystemException if a system exception occurred 1086 */ 1087 public static void addSCLicenses(long pk, long[] scLicensePKs) 1088 throws com.liferay.portal.kernel.exception.SystemException { 1089 getPersistence().addSCLicenses(pk, scLicensePKs); 1090 } 1091 1092 /** 1093 * 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. 1094 * 1095 * @param pk the primary key of the s c product entry 1096 * @param scLicenses the s c licenses 1097 * @throws SystemException if a system exception occurred 1098 */ 1099 public static void addSCLicenses(long pk, 1100 java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> scLicenses) 1101 throws com.liferay.portal.kernel.exception.SystemException { 1102 getPersistence().addSCLicenses(pk, scLicenses); 1103 } 1104 1105 /** 1106 * 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. 1107 * 1108 * @param pk the primary key of the s c product entry to clear the associated s c licenses from 1109 * @throws SystemException if a system exception occurred 1110 */ 1111 public static void clearSCLicenses(long pk) 1112 throws com.liferay.portal.kernel.exception.SystemException { 1113 getPersistence().clearSCLicenses(pk); 1114 } 1115 1116 /** 1117 * 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. 1118 * 1119 * @param pk the primary key of the s c product entry 1120 * @param scLicensePK the primary key of the s c license 1121 * @throws SystemException if a system exception occurred 1122 */ 1123 public static void removeSCLicense(long pk, long scLicensePK) 1124 throws com.liferay.portal.kernel.exception.SystemException { 1125 getPersistence().removeSCLicense(pk, scLicensePK); 1126 } 1127 1128 /** 1129 * 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. 1130 * 1131 * @param pk the primary key of the s c product entry 1132 * @param scLicense the s c license 1133 * @throws SystemException if a system exception occurred 1134 */ 1135 public static void removeSCLicense(long pk, 1136 com.liferay.portlet.softwarecatalog.model.SCLicense scLicense) 1137 throws com.liferay.portal.kernel.exception.SystemException { 1138 getPersistence().removeSCLicense(pk, scLicense); 1139 } 1140 1141 /** 1142 * 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. 1143 * 1144 * @param pk the primary key of the s c product entry 1145 * @param scLicensePKs the primary keys of the s c licenses 1146 * @throws SystemException if a system exception occurred 1147 */ 1148 public static void removeSCLicenses(long pk, long[] scLicensePKs) 1149 throws com.liferay.portal.kernel.exception.SystemException { 1150 getPersistence().removeSCLicenses(pk, scLicensePKs); 1151 } 1152 1153 /** 1154 * 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. 1155 * 1156 * @param pk the primary key of the s c product entry 1157 * @param scLicenses the s c licenses 1158 * @throws SystemException if a system exception occurred 1159 */ 1160 public static void removeSCLicenses(long pk, 1161 java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> scLicenses) 1162 throws com.liferay.portal.kernel.exception.SystemException { 1163 getPersistence().removeSCLicenses(pk, scLicenses); 1164 } 1165 1166 /** 1167 * 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. 1168 * 1169 * @param pk the primary key of the s c product entry 1170 * @param scLicensePKs the primary keys of the s c licenses to be associated with the s c product entry 1171 * @throws SystemException if a system exception occurred 1172 */ 1173 public static void setSCLicenses(long pk, long[] scLicensePKs) 1174 throws com.liferay.portal.kernel.exception.SystemException { 1175 getPersistence().setSCLicenses(pk, scLicensePKs); 1176 } 1177 1178 /** 1179 * 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. 1180 * 1181 * @param pk the primary key of the s c product entry 1182 * @param scLicenses the s c licenses to be associated with the s c product entry 1183 * @throws SystemException if a system exception occurred 1184 */ 1185 public static void setSCLicenses(long pk, 1186 java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> scLicenses) 1187 throws com.liferay.portal.kernel.exception.SystemException { 1188 getPersistence().setSCLicenses(pk, scLicenses); 1189 } 1190 1191 public static SCProductEntryPersistence getPersistence() { 1192 if (_persistence == null) { 1193 _persistence = (SCProductEntryPersistence)PortalBeanLocatorUtil.locate(SCProductEntryPersistence.class.getName()); 1194 1195 ReferenceRegistry.registerReference(SCProductEntryUtil.class, 1196 "_persistence"); 1197 } 1198 1199 return _persistence; 1200 } 1201 1202 public void setPersistence(SCProductEntryPersistence persistence) { 1203 _persistence = persistence; 1204 1205 ReferenceRegistry.registerReference(SCProductEntryUtil.class, 1206 "_persistence"); 1207 } 1208 1209 private static SCProductEntryPersistence _persistence; 1210 }