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