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.service.persistence.BasePersistence; 020 021 import com.liferay.portlet.softwarecatalog.model.SCProductEntry; 022 023 /** 024 * The persistence interface for the s c product entry service. 025 * 026 * <p> 027 * Caching information and settings can be found in <code>portal.properties</code> 028 * </p> 029 * 030 * @author Brian Wing Shun Chan 031 * @see com.liferay.portlet.softwarecatalog.service.persistence.impl.SCProductEntryPersistenceImpl 032 * @see SCProductEntryUtil 033 * @generated 034 */ 035 @ProviderType 036 public interface SCProductEntryPersistence extends BasePersistence<SCProductEntry> { 037 /* 038 * NOTE FOR DEVELOPERS: 039 * 040 * Never modify or reference this interface directly. Always use {@link SCProductEntryUtil} to access the s c product entry persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface. 041 */ 042 043 /** 044 * Returns all the s c product entries where groupId = ?. 045 * 046 * @param groupId the group ID 047 * @return the matching s c product entries 048 */ 049 public java.util.List<SCProductEntry> findByGroupId(long groupId); 050 051 /** 052 * Returns a range of all the s c product entries where groupId = ?. 053 * 054 * <p> 055 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SCProductEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 056 * </p> 057 * 058 * @param groupId the group ID 059 * @param start the lower bound of the range of s c product entries 060 * @param end the upper bound of the range of s c product entries (not inclusive) 061 * @return the range of matching s c product entries 062 */ 063 public java.util.List<SCProductEntry> findByGroupId(long groupId, 064 int start, int end); 065 066 /** 067 * Returns an ordered range of all the s c product entries where groupId = ?. 068 * 069 * <p> 070 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SCProductEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 071 * </p> 072 * 073 * @param groupId the group ID 074 * @param start the lower bound of the range of s c product entries 075 * @param end the upper bound of the range of s c product entries (not inclusive) 076 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 077 * @return the ordered range of matching s c product entries 078 */ 079 public java.util.List<SCProductEntry> findByGroupId(long groupId, 080 int start, int end, 081 com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator); 082 083 /** 084 * Returns the first s c product entry in the ordered set where groupId = ?. 085 * 086 * @param groupId the group ID 087 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 088 * @return the first matching s c product entry 089 * @throws NoSuchProductEntryException if a matching s c product entry could not be found 090 */ 091 public SCProductEntry findByGroupId_First(long groupId, 092 com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator) 093 throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException; 094 095 /** 096 * Returns the first s c product entry in the ordered set where groupId = ?. 097 * 098 * @param groupId the group ID 099 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 100 * @return the first matching s c product entry, or <code>null</code> if a matching s c product entry could not be found 101 */ 102 public SCProductEntry fetchByGroupId_First(long groupId, 103 com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator); 104 105 /** 106 * Returns the last s c product entry in the ordered set where groupId = ?. 107 * 108 * @param groupId the group ID 109 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 110 * @return the last matching s c product entry 111 * @throws NoSuchProductEntryException if a matching s c product entry could not be found 112 */ 113 public SCProductEntry findByGroupId_Last(long groupId, 114 com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator) 115 throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException; 116 117 /** 118 * Returns the last s c product entry in the ordered set where groupId = ?. 119 * 120 * @param groupId the group ID 121 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 122 * @return the last matching s c product entry, or <code>null</code> if a matching s c product entry could not be found 123 */ 124 public SCProductEntry fetchByGroupId_Last(long groupId, 125 com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator); 126 127 /** 128 * Returns the s c product entries before and after the current s c product entry in the ordered set where groupId = ?. 129 * 130 * @param productEntryId the primary key of the current s c product entry 131 * @param groupId the group ID 132 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 133 * @return the previous, current, and next s c product entry 134 * @throws NoSuchProductEntryException if a s c product entry with the primary key could not be found 135 */ 136 public SCProductEntry[] findByGroupId_PrevAndNext(long productEntryId, 137 long groupId, 138 com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator) 139 throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException; 140 141 /** 142 * Returns all the s c product entries that the user has permission to view where groupId = ?. 143 * 144 * @param groupId the group ID 145 * @return the matching s c product entries that the user has permission to view 146 */ 147 public java.util.List<SCProductEntry> filterFindByGroupId(long groupId); 148 149 /** 150 * Returns a range of all the s c product entries that the user has permission to view where groupId = ?. 151 * 152 * <p> 153 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SCProductEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 154 * </p> 155 * 156 * @param groupId the group ID 157 * @param start the lower bound of the range of s c product entries 158 * @param end the upper bound of the range of s c product entries (not inclusive) 159 * @return the range of matching s c product entries that the user has permission to view 160 */ 161 public java.util.List<SCProductEntry> filterFindByGroupId(long groupId, 162 int start, int end); 163 164 /** 165 * Returns an ordered range of all the s c product entries that the user has permissions to view where groupId = ?. 166 * 167 * <p> 168 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SCProductEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 169 * </p> 170 * 171 * @param groupId the group ID 172 * @param start the lower bound of the range of s c product entries 173 * @param end the upper bound of the range of s c product entries (not inclusive) 174 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 175 * @return the ordered range of matching s c product entries that the user has permission to view 176 */ 177 public java.util.List<SCProductEntry> filterFindByGroupId(long groupId, 178 int start, int end, 179 com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator); 180 181 /** 182 * 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 = ?. 183 * 184 * @param productEntryId the primary key of the current s c product entry 185 * @param groupId the group ID 186 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 187 * @return the previous, current, and next s c product entry 188 * @throws NoSuchProductEntryException if a s c product entry with the primary key could not be found 189 */ 190 public SCProductEntry[] filterFindByGroupId_PrevAndNext( 191 long productEntryId, long groupId, 192 com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator) 193 throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException; 194 195 /** 196 * Removes all the s c product entries where groupId = ? from the database. 197 * 198 * @param groupId the group ID 199 */ 200 public void removeByGroupId(long groupId); 201 202 /** 203 * Returns the number of s c product entries where groupId = ?. 204 * 205 * @param groupId the group ID 206 * @return the number of matching s c product entries 207 */ 208 public int countByGroupId(long groupId); 209 210 /** 211 * Returns the number of s c product entries that the user has permission to view where groupId = ?. 212 * 213 * @param groupId the group ID 214 * @return the number of matching s c product entries that the user has permission to view 215 */ 216 public int filterCountByGroupId(long groupId); 217 218 /** 219 * Returns all the s c product entries where companyId = ?. 220 * 221 * @param companyId the company ID 222 * @return the matching s c product entries 223 */ 224 public java.util.List<SCProductEntry> findByCompanyId(long companyId); 225 226 /** 227 * Returns a range of all the s c product entries where companyId = ?. 228 * 229 * <p> 230 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SCProductEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 231 * </p> 232 * 233 * @param companyId the company ID 234 * @param start the lower bound of the range of s c product entries 235 * @param end the upper bound of the range of s c product entries (not inclusive) 236 * @return the range of matching s c product entries 237 */ 238 public java.util.List<SCProductEntry> findByCompanyId(long companyId, 239 int start, int end); 240 241 /** 242 * Returns an ordered range of all the s c product entries where companyId = ?. 243 * 244 * <p> 245 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SCProductEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 246 * </p> 247 * 248 * @param companyId the company ID 249 * @param start the lower bound of the range of s c product entries 250 * @param end the upper bound of the range of s c product entries (not inclusive) 251 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 252 * @return the ordered range of matching s c product entries 253 */ 254 public java.util.List<SCProductEntry> findByCompanyId(long companyId, 255 int start, int end, 256 com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator); 257 258 /** 259 * Returns the first s c product entry in the ordered set where companyId = ?. 260 * 261 * @param companyId the company ID 262 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 263 * @return the first matching s c product entry 264 * @throws NoSuchProductEntryException if a matching s c product entry could not be found 265 */ 266 public SCProductEntry findByCompanyId_First(long companyId, 267 com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator) 268 throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException; 269 270 /** 271 * Returns the first s c product entry in the ordered set where companyId = ?. 272 * 273 * @param companyId the company ID 274 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 275 * @return the first matching s c product entry, or <code>null</code> if a matching s c product entry could not be found 276 */ 277 public SCProductEntry fetchByCompanyId_First(long companyId, 278 com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator); 279 280 /** 281 * Returns the last s c product entry in the ordered set where companyId = ?. 282 * 283 * @param companyId the company ID 284 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 285 * @return the last matching s c product entry 286 * @throws NoSuchProductEntryException if a matching s c product entry could not be found 287 */ 288 public SCProductEntry findByCompanyId_Last(long companyId, 289 com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator) 290 throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException; 291 292 /** 293 * Returns the last s c product entry in the ordered set where companyId = ?. 294 * 295 * @param companyId the company ID 296 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 297 * @return the last matching s c product entry, or <code>null</code> if a matching s c product entry could not be found 298 */ 299 public SCProductEntry fetchByCompanyId_Last(long companyId, 300 com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator); 301 302 /** 303 * Returns the s c product entries before and after the current s c product entry in the ordered set where companyId = ?. 304 * 305 * @param productEntryId the primary key of the current s c product entry 306 * @param companyId the company ID 307 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 308 * @return the previous, current, and next s c product entry 309 * @throws NoSuchProductEntryException if a s c product entry with the primary key could not be found 310 */ 311 public SCProductEntry[] findByCompanyId_PrevAndNext(long productEntryId, 312 long companyId, 313 com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator) 314 throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException; 315 316 /** 317 * Removes all the s c product entries where companyId = ? from the database. 318 * 319 * @param companyId the company ID 320 */ 321 public void removeByCompanyId(long companyId); 322 323 /** 324 * Returns the number of s c product entries where companyId = ?. 325 * 326 * @param companyId the company ID 327 * @return the number of matching s c product entries 328 */ 329 public int countByCompanyId(long companyId); 330 331 /** 332 * Returns all the s c product entries where groupId = ? and userId = ?. 333 * 334 * @param groupId the group ID 335 * @param userId the user ID 336 * @return the matching s c product entries 337 */ 338 public java.util.List<SCProductEntry> findByG_U(long groupId, long userId); 339 340 /** 341 * Returns a range of all the s c product entries where groupId = ? and userId = ?. 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SCProductEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 345 * </p> 346 * 347 * @param groupId the group ID 348 * @param userId the user ID 349 * @param start the lower bound of the range of s c product entries 350 * @param end the upper bound of the range of s c product entries (not inclusive) 351 * @return the range of matching s c product entries 352 */ 353 public java.util.List<SCProductEntry> findByG_U(long groupId, long userId, 354 int start, int end); 355 356 /** 357 * Returns an ordered range of all the s c product entries where groupId = ? and userId = ?. 358 * 359 * <p> 360 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SCProductEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 361 * </p> 362 * 363 * @param groupId the group ID 364 * @param userId the user 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 java.util.List<SCProductEntry> findByG_U(long groupId, long userId, 371 int start, int end, 372 com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator); 373 374 /** 375 * Returns the first s c product entry in the ordered set where groupId = ? and userId = ?. 376 * 377 * @param groupId the group ID 378 * @param userId the user ID 379 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 380 * @return the first matching s c product entry 381 * @throws NoSuchProductEntryException if a matching s c product entry could not be found 382 */ 383 public SCProductEntry findByG_U_First(long groupId, long userId, 384 com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator) 385 throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException; 386 387 /** 388 * Returns the first s c product entry in the ordered set where groupId = ? and userId = ?. 389 * 390 * @param groupId the group ID 391 * @param userId the user ID 392 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 393 * @return the first matching s c product entry, or <code>null</code> if a matching s c product entry could not be found 394 */ 395 public SCProductEntry fetchByG_U_First(long groupId, long userId, 396 com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator); 397 398 /** 399 * Returns the last s c product entry in the ordered set where groupId = ? and userId = ?. 400 * 401 * @param groupId the group ID 402 * @param userId the user ID 403 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 404 * @return the last matching s c product entry 405 * @throws NoSuchProductEntryException if a matching s c product entry could not be found 406 */ 407 public SCProductEntry findByG_U_Last(long groupId, long userId, 408 com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator) 409 throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException; 410 411 /** 412 * Returns the last s c product entry in the ordered set where groupId = ? and userId = ?. 413 * 414 * @param groupId the group ID 415 * @param userId the user ID 416 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 417 * @return the last matching s c product entry, or <code>null</code> if a matching s c product entry could not be found 418 */ 419 public SCProductEntry fetchByG_U_Last(long groupId, long userId, 420 com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator); 421 422 /** 423 * Returns the s c product entries before and after the current s c product entry in the ordered set where groupId = ? and userId = ?. 424 * 425 * @param productEntryId the primary key of the current s c product entry 426 * @param groupId the group ID 427 * @param userId the user ID 428 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 429 * @return the previous, current, and next s c product entry 430 * @throws NoSuchProductEntryException if a s c product entry with the primary key could not be found 431 */ 432 public SCProductEntry[] findByG_U_PrevAndNext(long productEntryId, 433 long groupId, long userId, 434 com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator) 435 throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException; 436 437 /** 438 * Returns all the s c product entries that the user has permission to view where groupId = ? and userId = ?. 439 * 440 * @param groupId the group ID 441 * @param userId the user ID 442 * @return the matching s c product entries that the user has permission to view 443 */ 444 public java.util.List<SCProductEntry> filterFindByG_U(long groupId, 445 long userId); 446 447 /** 448 * Returns a range of all the s c product entries that the user has permission to view where groupId = ? and userId = ?. 449 * 450 * <p> 451 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SCProductEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 452 * </p> 453 * 454 * @param groupId the group ID 455 * @param userId the user ID 456 * @param start the lower bound of the range of s c product entries 457 * @param end the upper bound of the range of s c product entries (not inclusive) 458 * @return the range of matching s c product entries that the user has permission to view 459 */ 460 public java.util.List<SCProductEntry> filterFindByG_U(long groupId, 461 long userId, int start, int end); 462 463 /** 464 * Returns an ordered range of all the s c product entries that the user has permissions to view where groupId = ? and userId = ?. 465 * 466 * <p> 467 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SCProductEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 468 * </p> 469 * 470 * @param groupId the group ID 471 * @param userId the user ID 472 * @param start the lower bound of the range of s c product entries 473 * @param end the upper bound of the range of s c product entries (not inclusive) 474 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 475 * @return the ordered range of matching s c product entries that the user has permission to view 476 */ 477 public java.util.List<SCProductEntry> filterFindByG_U(long groupId, 478 long userId, int start, int end, 479 com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator); 480 481 /** 482 * 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 = ?. 483 * 484 * @param productEntryId the primary key of the current s c product entry 485 * @param groupId the group ID 486 * @param userId the user 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 NoSuchProductEntryException if a s c product entry with the primary key could not be found 490 */ 491 public SCProductEntry[] filterFindByG_U_PrevAndNext(long productEntryId, 492 long groupId, long userId, 493 com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator) 494 throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException; 495 496 /** 497 * Removes all the s c product entries where groupId = ? and userId = ? from the database. 498 * 499 * @param groupId the group ID 500 * @param userId the user ID 501 */ 502 public void removeByG_U(long groupId, long userId); 503 504 /** 505 * Returns the number of s c product entries where groupId = ? and userId = ?. 506 * 507 * @param groupId the group ID 508 * @param userId the user ID 509 * @return the number of matching s c product entries 510 */ 511 public int countByG_U(long groupId, long userId); 512 513 /** 514 * Returns the number of s c product entries that the user has permission to view where groupId = ? and userId = ?. 515 * 516 * @param groupId the group ID 517 * @param userId the user ID 518 * @return the number of matching s c product entries that the user has permission to view 519 */ 520 public int filterCountByG_U(long groupId, long userId); 521 522 /** 523 * Returns the s c product entry where repoGroupId = ? and repoArtifactId = ? or throws a {@link NoSuchProductEntryException} if it could not be found. 524 * 525 * @param repoGroupId the repo group ID 526 * @param repoArtifactId the repo artifact ID 527 * @return the matching s c product entry 528 * @throws NoSuchProductEntryException if a matching s c product entry could not be found 529 */ 530 public SCProductEntry findByRG_RA(java.lang.String repoGroupId, 531 java.lang.String repoArtifactId) 532 throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException; 533 534 /** 535 * 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. 536 * 537 * @param repoGroupId the repo group ID 538 * @param repoArtifactId the repo artifact ID 539 * @return the matching s c product entry, or <code>null</code> if a matching s c product entry could not be found 540 */ 541 public SCProductEntry fetchByRG_RA(java.lang.String repoGroupId, 542 java.lang.String repoArtifactId); 543 544 /** 545 * 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. 546 * 547 * @param repoGroupId the repo group ID 548 * @param repoArtifactId the repo artifact ID 549 * @param retrieveFromCache whether to use the finder cache 550 * @return the matching s c product entry, or <code>null</code> if a matching s c product entry could not be found 551 */ 552 public SCProductEntry fetchByRG_RA(java.lang.String repoGroupId, 553 java.lang.String repoArtifactId, boolean retrieveFromCache); 554 555 /** 556 * Removes the s c product entry where repoGroupId = ? and repoArtifactId = ? from the database. 557 * 558 * @param repoGroupId the repo group ID 559 * @param repoArtifactId the repo artifact ID 560 * @return the s c product entry that was removed 561 */ 562 public SCProductEntry removeByRG_RA(java.lang.String repoGroupId, 563 java.lang.String repoArtifactId) 564 throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException; 565 566 /** 567 * Returns the number of s c product entries where repoGroupId = ? and repoArtifactId = ?. 568 * 569 * @param repoGroupId the repo group ID 570 * @param repoArtifactId the repo artifact ID 571 * @return the number of matching s c product entries 572 */ 573 public int countByRG_RA(java.lang.String repoGroupId, 574 java.lang.String repoArtifactId); 575 576 /** 577 * Caches the s c product entry in the entity cache if it is enabled. 578 * 579 * @param scProductEntry the s c product entry 580 */ 581 public void cacheResult(SCProductEntry scProductEntry); 582 583 /** 584 * Caches the s c product entries in the entity cache if it is enabled. 585 * 586 * @param scProductEntries the s c product entries 587 */ 588 public void cacheResult(java.util.List<SCProductEntry> scProductEntries); 589 590 /** 591 * Creates a new s c product entry with the primary key. Does not add the s c product entry to the database. 592 * 593 * @param productEntryId the primary key for the new s c product entry 594 * @return the new s c product entry 595 */ 596 public SCProductEntry create(long productEntryId); 597 598 /** 599 * Removes the s c product entry with the primary key from the database. Also notifies the appropriate model listeners. 600 * 601 * @param productEntryId the primary key of the s c product entry 602 * @return the s c product entry that was removed 603 * @throws NoSuchProductEntryException if a s c product entry with the primary key could not be found 604 */ 605 public SCProductEntry remove(long productEntryId) 606 throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException; 607 608 public SCProductEntry updateImpl(SCProductEntry scProductEntry); 609 610 /** 611 * Returns the s c product entry with the primary key or throws a {@link NoSuchProductEntryException} if it could not be found. 612 * 613 * @param productEntryId the primary key of the s c product entry 614 * @return the s c product entry 615 * @throws NoSuchProductEntryException if a s c product entry with the primary key could not be found 616 */ 617 public SCProductEntry findByPrimaryKey(long productEntryId) 618 throws com.liferay.portlet.softwarecatalog.NoSuchProductEntryException; 619 620 /** 621 * Returns the s c product entry with the primary key or returns <code>null</code> if it could not be found. 622 * 623 * @param productEntryId the primary key of the s c product entry 624 * @return the s c product entry, or <code>null</code> if a s c product entry with the primary key could not be found 625 */ 626 public SCProductEntry fetchByPrimaryKey(long productEntryId); 627 628 @Override 629 public java.util.Map<java.io.Serializable, SCProductEntry> fetchByPrimaryKeys( 630 java.util.Set<java.io.Serializable> primaryKeys); 631 632 /** 633 * Returns all the s c product entries. 634 * 635 * @return the s c product entries 636 */ 637 public java.util.List<SCProductEntry> findAll(); 638 639 /** 640 * Returns a range of all the s c product entries. 641 * 642 * <p> 643 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SCProductEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 644 * </p> 645 * 646 * @param start the lower bound of the range of s c product entries 647 * @param end the upper bound of the range of s c product entries (not inclusive) 648 * @return the range of s c product entries 649 */ 650 public java.util.List<SCProductEntry> findAll(int start, int end); 651 652 /** 653 * Returns an ordered range of all the s c product entries. 654 * 655 * <p> 656 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SCProductEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 657 * </p> 658 * 659 * @param start the lower bound of the range of s c product entries 660 * @param end the upper bound of the range of s c product entries (not inclusive) 661 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 662 * @return the ordered range of s c product entries 663 */ 664 public java.util.List<SCProductEntry> findAll(int start, int end, 665 com.liferay.portal.kernel.util.OrderByComparator<SCProductEntry> orderByComparator); 666 667 /** 668 * Removes all the s c product entries from the database. 669 */ 670 public void removeAll(); 671 672 /** 673 * Returns the number of s c product entries. 674 * 675 * @return the number of s c product entries 676 */ 677 public int countAll(); 678 679 /** 680 * Returns the primaryKeys of s c licenses associated with the s c product entry. 681 * 682 * @param pk the primary key of the s c product entry 683 * @return long[] of the primaryKeys of s c licenses associated with the s c product entry 684 */ 685 public long[] getSCLicensePrimaryKeys(long pk); 686 687 /** 688 * Returns all the s c licenses associated with the s c product entry. 689 * 690 * @param pk the primary key of the s c product entry 691 * @return the s c licenses associated with the s c product entry 692 */ 693 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> getSCLicenses( 694 long pk); 695 696 /** 697 * Returns a range of all the s c licenses associated with the s c product entry. 698 * 699 * <p> 700 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SCProductEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 701 * </p> 702 * 703 * @param pk the primary key of the s c product entry 704 * @param start the lower bound of the range of s c product entries 705 * @param end the upper bound of the range of s c product entries (not inclusive) 706 * @return the range of s c licenses associated with the s c product entry 707 */ 708 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> getSCLicenses( 709 long pk, int start, int end); 710 711 /** 712 * Returns an ordered range of all the s c licenses associated with the s c product entry. 713 * 714 * <p> 715 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link SCProductEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 716 * </p> 717 * 718 * @param pk the primary key of the s c product entry 719 * @param start the lower bound of the range of s c product entries 720 * @param end the upper bound of the range of s c product entries (not inclusive) 721 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 722 * @return the ordered range of s c licenses associated with the s c product entry 723 */ 724 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> getSCLicenses( 725 long pk, int start, int end, 726 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.softwarecatalog.model.SCLicense> orderByComparator); 727 728 /** 729 * Returns the number of s c licenses associated with the s c product entry. 730 * 731 * @param pk the primary key of the s c product entry 732 * @return the number of s c licenses associated with the s c product entry 733 */ 734 public int getSCLicensesSize(long pk); 735 736 /** 737 * Returns <code>true</code> if the s c license is associated with the s c product entry. 738 * 739 * @param pk the primary key of the s c product entry 740 * @param scLicensePK the primary key of the s c license 741 * @return <code>true</code> if the s c license is associated with the s c product entry; <code>false</code> otherwise 742 */ 743 public boolean containsSCLicense(long pk, long scLicensePK); 744 745 /** 746 * Returns <code>true</code> if the s c product entry has any s c licenses associated with it. 747 * 748 * @param pk the primary key of the s c product entry to check for associations with s c licenses 749 * @return <code>true</code> if the s c product entry has any s c licenses associated with it; <code>false</code> otherwise 750 */ 751 public boolean containsSCLicenses(long pk); 752 753 /** 754 * 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. 755 * 756 * @param pk the primary key of the s c product entry 757 * @param scLicensePK the primary key of the s c license 758 */ 759 public void addSCLicense(long pk, long scLicensePK); 760 761 /** 762 * 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. 763 * 764 * @param pk the primary key of the s c product entry 765 * @param scLicense the s c license 766 */ 767 public void addSCLicense(long pk, 768 com.liferay.portlet.softwarecatalog.model.SCLicense scLicense); 769 770 /** 771 * 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. 772 * 773 * @param pk the primary key of the s c product entry 774 * @param scLicensePKs the primary keys of the s c licenses 775 */ 776 public void addSCLicenses(long pk, long[] scLicensePKs); 777 778 /** 779 * 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. 780 * 781 * @param pk the primary key of the s c product entry 782 * @param scLicenses the s c licenses 783 */ 784 public void addSCLicenses(long pk, 785 java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> scLicenses); 786 787 /** 788 * 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. 789 * 790 * @param pk the primary key of the s c product entry to clear the associated s c licenses from 791 */ 792 public void clearSCLicenses(long pk); 793 794 /** 795 * 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. 796 * 797 * @param pk the primary key of the s c product entry 798 * @param scLicensePK the primary key of the s c license 799 */ 800 public void removeSCLicense(long pk, long scLicensePK); 801 802 /** 803 * 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. 804 * 805 * @param pk the primary key of the s c product entry 806 * @param scLicense the s c license 807 */ 808 public void removeSCLicense(long pk, 809 com.liferay.portlet.softwarecatalog.model.SCLicense scLicense); 810 811 /** 812 * 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. 813 * 814 * @param pk the primary key of the s c product entry 815 * @param scLicensePKs the primary keys of the s c licenses 816 */ 817 public void removeSCLicenses(long pk, long[] scLicensePKs); 818 819 /** 820 * 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. 821 * 822 * @param pk the primary key of the s c product entry 823 * @param scLicenses the s c licenses 824 */ 825 public void removeSCLicenses(long pk, 826 java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> scLicenses); 827 828 /** 829 * 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. 830 * 831 * @param pk the primary key of the s c product entry 832 * @param scLicensePKs the primary keys of the s c licenses to be associated with the s c product entry 833 */ 834 public void setSCLicenses(long pk, long[] scLicensePKs); 835 836 /** 837 * 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. 838 * 839 * @param pk the primary key of the s c product entry 840 * @param scLicenses the s c licenses to be associated with the s c product entry 841 */ 842 public void setSCLicenses(long pk, 843 java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> scLicenses); 844 }