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