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