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