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