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