001 /** 002 * Copyright (c) 2000-2013 Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portlet.softwarecatalog.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.service.persistence.BasePersistence; 020 021 import com.liferay.portlet.softwarecatalog.model.SCLicense; 022 023 /** 024 * The persistence interface for the s c license 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 SCLicensePersistenceImpl 032 * @see SCLicenseUtil 033 * @generated 034 */ 035 @ProviderType 036 public interface SCLicensePersistence extends BasePersistence<SCLicense> { 037 /* 038 * NOTE FOR DEVELOPERS: 039 * 040 * Never modify or reference this interface directly. Always use {@link SCLicenseUtil} to access the s c license persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface. 041 */ 042 043 /** 044 * Returns all the s c licenses where active = ?. 045 * 046 * @param active the active 047 * @return the matching s c licenses 048 * @throws SystemException if a system exception occurred 049 */ 050 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByActive( 051 boolean active) 052 throws com.liferay.portal.kernel.exception.SystemException; 053 054 /** 055 * Returns a range of all the s c licenses where active = ?. 056 * 057 * <p> 058 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCLicenseModelImpl}. 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. 059 * </p> 060 * 061 * @param active the active 062 * @param start the lower bound of the range of s c licenses 063 * @param end the upper bound of the range of s c licenses (not inclusive) 064 * @return the range of matching s c licenses 065 * @throws SystemException if a system exception occurred 066 */ 067 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByActive( 068 boolean active, int start, int end) 069 throws com.liferay.portal.kernel.exception.SystemException; 070 071 /** 072 * Returns an ordered range of all the s c licenses where active = ?. 073 * 074 * <p> 075 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCLicenseModelImpl}. 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. 076 * </p> 077 * 078 * @param active the active 079 * @param start the lower bound of the range of s c licenses 080 * @param end the upper bound of the range of s c licenses (not inclusive) 081 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 082 * @return the ordered range of matching s c licenses 083 * @throws SystemException if a system exception occurred 084 */ 085 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByActive( 086 boolean active, int start, int end, 087 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 088 throws com.liferay.portal.kernel.exception.SystemException; 089 090 /** 091 * Returns the first s c license in the ordered set where active = ?. 092 * 093 * @param active the active 094 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 095 * @return the first matching s c license 096 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a matching s c license could not be found 097 * @throws SystemException if a system exception occurred 098 */ 099 public com.liferay.portlet.softwarecatalog.model.SCLicense findByActive_First( 100 boolean active, 101 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 102 throws com.liferay.portal.kernel.exception.SystemException, 103 com.liferay.portlet.softwarecatalog.NoSuchLicenseException; 104 105 /** 106 * Returns the first s c license in the ordered set where active = ?. 107 * 108 * @param active the active 109 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 110 * @return the first matching s c license, or <code>null</code> if a matching s c license could not be found 111 * @throws SystemException if a system exception occurred 112 */ 113 public com.liferay.portlet.softwarecatalog.model.SCLicense fetchByActive_First( 114 boolean active, 115 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 116 throws com.liferay.portal.kernel.exception.SystemException; 117 118 /** 119 * Returns the last s c license in the ordered set where active = ?. 120 * 121 * @param active the active 122 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 123 * @return the last matching s c license 124 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a matching s c license could not be found 125 * @throws SystemException if a system exception occurred 126 */ 127 public com.liferay.portlet.softwarecatalog.model.SCLicense findByActive_Last( 128 boolean active, 129 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 130 throws com.liferay.portal.kernel.exception.SystemException, 131 com.liferay.portlet.softwarecatalog.NoSuchLicenseException; 132 133 /** 134 * Returns the last s c license in the ordered set where active = ?. 135 * 136 * @param active the active 137 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 138 * @return the last matching s c license, or <code>null</code> if a matching s c license could not be found 139 * @throws SystemException if a system exception occurred 140 */ 141 public com.liferay.portlet.softwarecatalog.model.SCLicense fetchByActive_Last( 142 boolean active, 143 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 144 throws com.liferay.portal.kernel.exception.SystemException; 145 146 /** 147 * Returns the s c licenses before and after the current s c license in the ordered set where active = ?. 148 * 149 * @param licenseId the primary key of the current s c license 150 * @param active the active 151 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 152 * @return the previous, current, and next s c license 153 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found 154 * @throws SystemException if a system exception occurred 155 */ 156 public com.liferay.portlet.softwarecatalog.model.SCLicense[] findByActive_PrevAndNext( 157 long licenseId, boolean active, 158 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 159 throws com.liferay.portal.kernel.exception.SystemException, 160 com.liferay.portlet.softwarecatalog.NoSuchLicenseException; 161 162 /** 163 * Returns all the s c licenses that the user has permission to view where active = ?. 164 * 165 * @param active the active 166 * @return the matching s c licenses that the user has permission to view 167 * @throws SystemException if a system exception occurred 168 */ 169 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByActive( 170 boolean active) 171 throws com.liferay.portal.kernel.exception.SystemException; 172 173 /** 174 * Returns a range of all the s c licenses that the user has permission to view where active = ?. 175 * 176 * <p> 177 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCLicenseModelImpl}. 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. 178 * </p> 179 * 180 * @param active the active 181 * @param start the lower bound of the range of s c licenses 182 * @param end the upper bound of the range of s c licenses (not inclusive) 183 * @return the range of matching s c licenses that the user has permission to view 184 * @throws SystemException if a system exception occurred 185 */ 186 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByActive( 187 boolean active, int start, int end) 188 throws com.liferay.portal.kernel.exception.SystemException; 189 190 /** 191 * Returns an ordered range of all the s c licenses that the user has permissions to view where active = ?. 192 * 193 * <p> 194 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCLicenseModelImpl}. 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. 195 * </p> 196 * 197 * @param active the active 198 * @param start the lower bound of the range of s c licenses 199 * @param end the upper bound of the range of s c licenses (not inclusive) 200 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 201 * @return the ordered range of matching s c licenses that the user has permission to view 202 * @throws SystemException if a system exception occurred 203 */ 204 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByActive( 205 boolean active, int start, int end, 206 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 207 throws com.liferay.portal.kernel.exception.SystemException; 208 209 /** 210 * Returns the s c licenses before and after the current s c license in the ordered set of s c licenses that the user has permission to view where active = ?. 211 * 212 * @param licenseId the primary key of the current s c license 213 * @param active the active 214 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 215 * @return the previous, current, and next s c license 216 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found 217 * @throws SystemException if a system exception occurred 218 */ 219 public com.liferay.portlet.softwarecatalog.model.SCLicense[] filterFindByActive_PrevAndNext( 220 long licenseId, boolean active, 221 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 222 throws com.liferay.portal.kernel.exception.SystemException, 223 com.liferay.portlet.softwarecatalog.NoSuchLicenseException; 224 225 /** 226 * Removes all the s c licenses where active = ? from the database. 227 * 228 * @param active the active 229 * @throws SystemException if a system exception occurred 230 */ 231 public void removeByActive(boolean active) 232 throws com.liferay.portal.kernel.exception.SystemException; 233 234 /** 235 * Returns the number of s c licenses where active = ?. 236 * 237 * @param active the active 238 * @return the number of matching s c licenses 239 * @throws SystemException if a system exception occurred 240 */ 241 public int countByActive(boolean active) 242 throws com.liferay.portal.kernel.exception.SystemException; 243 244 /** 245 * Returns the number of s c licenses that the user has permission to view where active = ?. 246 * 247 * @param active the active 248 * @return the number of matching s c licenses that the user has permission to view 249 * @throws SystemException if a system exception occurred 250 */ 251 public int filterCountByActive(boolean active) 252 throws com.liferay.portal.kernel.exception.SystemException; 253 254 /** 255 * Returns all the s c licenses where active = ? and recommended = ?. 256 * 257 * @param active the active 258 * @param recommended the recommended 259 * @return the matching s c licenses 260 * @throws SystemException if a system exception occurred 261 */ 262 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByA_R( 263 boolean active, boolean recommended) 264 throws com.liferay.portal.kernel.exception.SystemException; 265 266 /** 267 * Returns a range of all the s c licenses where active = ? and recommended = ?. 268 * 269 * <p> 270 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCLicenseModelImpl}. 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. 271 * </p> 272 * 273 * @param active the active 274 * @param recommended the recommended 275 * @param start the lower bound of the range of s c licenses 276 * @param end the upper bound of the range of s c licenses (not inclusive) 277 * @return the range of matching s c licenses 278 * @throws SystemException if a system exception occurred 279 */ 280 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByA_R( 281 boolean active, boolean recommended, int start, int end) 282 throws com.liferay.portal.kernel.exception.SystemException; 283 284 /** 285 * Returns an ordered range of all the s c licenses where active = ? and recommended = ?. 286 * 287 * <p> 288 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCLicenseModelImpl}. 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. 289 * </p> 290 * 291 * @param active the active 292 * @param recommended the recommended 293 * @param start the lower bound of the range of s c licenses 294 * @param end the upper bound of the range of s c licenses (not inclusive) 295 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 296 * @return the ordered range of matching s c licenses 297 * @throws SystemException if a system exception occurred 298 */ 299 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findByA_R( 300 boolean active, boolean recommended, int start, int end, 301 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 302 throws com.liferay.portal.kernel.exception.SystemException; 303 304 /** 305 * Returns the first s c license in the ordered set where active = ? and recommended = ?. 306 * 307 * @param active the active 308 * @param recommended the recommended 309 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 310 * @return the first matching s c license 311 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a matching s c license could not be found 312 * @throws SystemException if a system exception occurred 313 */ 314 public com.liferay.portlet.softwarecatalog.model.SCLicense findByA_R_First( 315 boolean active, boolean recommended, 316 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 317 throws com.liferay.portal.kernel.exception.SystemException, 318 com.liferay.portlet.softwarecatalog.NoSuchLicenseException; 319 320 /** 321 * Returns the first s c license in the ordered set where active = ? and recommended = ?. 322 * 323 * @param active the active 324 * @param recommended the recommended 325 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 326 * @return the first matching s c license, or <code>null</code> if a matching s c license could not be found 327 * @throws SystemException if a system exception occurred 328 */ 329 public com.liferay.portlet.softwarecatalog.model.SCLicense fetchByA_R_First( 330 boolean active, boolean recommended, 331 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 332 throws com.liferay.portal.kernel.exception.SystemException; 333 334 /** 335 * Returns the last s c license in the ordered set where active = ? and recommended = ?. 336 * 337 * @param active the active 338 * @param recommended the recommended 339 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 340 * @return the last matching s c license 341 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a matching s c license could not be found 342 * @throws SystemException if a system exception occurred 343 */ 344 public com.liferay.portlet.softwarecatalog.model.SCLicense findByA_R_Last( 345 boolean active, boolean recommended, 346 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 347 throws com.liferay.portal.kernel.exception.SystemException, 348 com.liferay.portlet.softwarecatalog.NoSuchLicenseException; 349 350 /** 351 * Returns the last s c license in the ordered set where active = ? and recommended = ?. 352 * 353 * @param active the active 354 * @param recommended the recommended 355 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 356 * @return the last matching s c license, or <code>null</code> if a matching s c license could not be found 357 * @throws SystemException if a system exception occurred 358 */ 359 public com.liferay.portlet.softwarecatalog.model.SCLicense fetchByA_R_Last( 360 boolean active, boolean recommended, 361 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 362 throws com.liferay.portal.kernel.exception.SystemException; 363 364 /** 365 * Returns the s c licenses before and after the current s c license in the ordered set where active = ? and recommended = ?. 366 * 367 * @param licenseId the primary key of the current s c license 368 * @param active the active 369 * @param recommended the recommended 370 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 371 * @return the previous, current, and next s c license 372 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found 373 * @throws SystemException if a system exception occurred 374 */ 375 public com.liferay.portlet.softwarecatalog.model.SCLicense[] findByA_R_PrevAndNext( 376 long licenseId, boolean active, boolean recommended, 377 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 378 throws com.liferay.portal.kernel.exception.SystemException, 379 com.liferay.portlet.softwarecatalog.NoSuchLicenseException; 380 381 /** 382 * Returns all the s c licenses that the user has permission to view where active = ? and recommended = ?. 383 * 384 * @param active the active 385 * @param recommended the recommended 386 * @return the matching s c licenses that the user has permission to view 387 * @throws SystemException if a system exception occurred 388 */ 389 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByA_R( 390 boolean active, boolean recommended) 391 throws com.liferay.portal.kernel.exception.SystemException; 392 393 /** 394 * Returns a range of all the s c licenses that the user has permission to view where active = ? and recommended = ?. 395 * 396 * <p> 397 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCLicenseModelImpl}. 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. 398 * </p> 399 * 400 * @param active the active 401 * @param recommended the recommended 402 * @param start the lower bound of the range of s c licenses 403 * @param end the upper bound of the range of s c licenses (not inclusive) 404 * @return the range of matching s c licenses that the user has permission to view 405 * @throws SystemException if a system exception occurred 406 */ 407 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByA_R( 408 boolean active, boolean recommended, int start, int end) 409 throws com.liferay.portal.kernel.exception.SystemException; 410 411 /** 412 * Returns an ordered range of all the s c licenses that the user has permissions to view where active = ? and recommended = ?. 413 * 414 * <p> 415 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCLicenseModelImpl}. 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. 416 * </p> 417 * 418 * @param active the active 419 * @param recommended the recommended 420 * @param start the lower bound of the range of s c licenses 421 * @param end the upper bound of the range of s c licenses (not inclusive) 422 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 423 * @return the ordered range of matching s c licenses that the user has permission to view 424 * @throws SystemException if a system exception occurred 425 */ 426 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> filterFindByA_R( 427 boolean active, boolean recommended, int start, int end, 428 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 429 throws com.liferay.portal.kernel.exception.SystemException; 430 431 /** 432 * Returns the s c licenses before and after the current s c license in the ordered set of s c licenses that the user has permission to view where active = ? and recommended = ?. 433 * 434 * @param licenseId the primary key of the current s c license 435 * @param active the active 436 * @param recommended the recommended 437 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 438 * @return the previous, current, and next s c license 439 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found 440 * @throws SystemException if a system exception occurred 441 */ 442 public com.liferay.portlet.softwarecatalog.model.SCLicense[] filterFindByA_R_PrevAndNext( 443 long licenseId, boolean active, boolean recommended, 444 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 445 throws com.liferay.portal.kernel.exception.SystemException, 446 com.liferay.portlet.softwarecatalog.NoSuchLicenseException; 447 448 /** 449 * Removes all the s c licenses where active = ? and recommended = ? from the database. 450 * 451 * @param active the active 452 * @param recommended the recommended 453 * @throws SystemException if a system exception occurred 454 */ 455 public void removeByA_R(boolean active, boolean recommended) 456 throws com.liferay.portal.kernel.exception.SystemException; 457 458 /** 459 * Returns the number of s c licenses where active = ? and recommended = ?. 460 * 461 * @param active the active 462 * @param recommended the recommended 463 * @return the number of matching s c licenses 464 * @throws SystemException if a system exception occurred 465 */ 466 public int countByA_R(boolean active, boolean recommended) 467 throws com.liferay.portal.kernel.exception.SystemException; 468 469 /** 470 * Returns the number of s c licenses that the user has permission to view where active = ? and recommended = ?. 471 * 472 * @param active the active 473 * @param recommended the recommended 474 * @return the number of matching s c licenses that the user has permission to view 475 * @throws SystemException if a system exception occurred 476 */ 477 public int filterCountByA_R(boolean active, boolean recommended) 478 throws com.liferay.portal.kernel.exception.SystemException; 479 480 /** 481 * Caches the s c license in the entity cache if it is enabled. 482 * 483 * @param scLicense the s c license 484 */ 485 public void cacheResult( 486 com.liferay.portlet.softwarecatalog.model.SCLicense scLicense); 487 488 /** 489 * Caches the s c licenses in the entity cache if it is enabled. 490 * 491 * @param scLicenses the s c licenses 492 */ 493 public void cacheResult( 494 java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> scLicenses); 495 496 /** 497 * Creates a new s c license with the primary key. Does not add the s c license to the database. 498 * 499 * @param licenseId the primary key for the new s c license 500 * @return the new s c license 501 */ 502 public com.liferay.portlet.softwarecatalog.model.SCLicense create( 503 long licenseId); 504 505 /** 506 * Removes the s c license with the primary key from the database. Also notifies the appropriate model listeners. 507 * 508 * @param licenseId the primary key of the s c license 509 * @return the s c license that was removed 510 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found 511 * @throws SystemException if a system exception occurred 512 */ 513 public com.liferay.portlet.softwarecatalog.model.SCLicense remove( 514 long licenseId) 515 throws com.liferay.portal.kernel.exception.SystemException, 516 com.liferay.portlet.softwarecatalog.NoSuchLicenseException; 517 518 public com.liferay.portlet.softwarecatalog.model.SCLicense updateImpl( 519 com.liferay.portlet.softwarecatalog.model.SCLicense scLicense) 520 throws com.liferay.portal.kernel.exception.SystemException; 521 522 /** 523 * Returns the s c license with the primary key or throws a {@link com.liferay.portlet.softwarecatalog.NoSuchLicenseException} if it could not be found. 524 * 525 * @param licenseId the primary key of the s c license 526 * @return the s c license 527 * @throws com.liferay.portlet.softwarecatalog.NoSuchLicenseException if a s c license with the primary key could not be found 528 * @throws SystemException if a system exception occurred 529 */ 530 public com.liferay.portlet.softwarecatalog.model.SCLicense findByPrimaryKey( 531 long licenseId) 532 throws com.liferay.portal.kernel.exception.SystemException, 533 com.liferay.portlet.softwarecatalog.NoSuchLicenseException; 534 535 /** 536 * Returns the s c license with the primary key or returns <code>null</code> if it could not be found. 537 * 538 * @param licenseId the primary key of the s c license 539 * @return the s c license, or <code>null</code> if a s c license with the primary key could not be found 540 * @throws SystemException if a system exception occurred 541 */ 542 public com.liferay.portlet.softwarecatalog.model.SCLicense fetchByPrimaryKey( 543 long licenseId) 544 throws com.liferay.portal.kernel.exception.SystemException; 545 546 /** 547 * Returns all the s c licenses. 548 * 549 * @return the s c licenses 550 * @throws SystemException if a system exception occurred 551 */ 552 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findAll() 553 throws com.liferay.portal.kernel.exception.SystemException; 554 555 /** 556 * Returns a range of all the s c licenses. 557 * 558 * <p> 559 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCLicenseModelImpl}. 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. 560 * </p> 561 * 562 * @param start the lower bound of the range of s c licenses 563 * @param end the upper bound of the range of s c licenses (not inclusive) 564 * @return the range of s c licenses 565 * @throws SystemException if a system exception occurred 566 */ 567 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findAll( 568 int start, int end) 569 throws com.liferay.portal.kernel.exception.SystemException; 570 571 /** 572 * Returns an ordered range of all the s c licenses. 573 * 574 * <p> 575 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCLicenseModelImpl}. 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. 576 * </p> 577 * 578 * @param start the lower bound of the range of s c licenses 579 * @param end the upper bound of the range of s c licenses (not inclusive) 580 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 581 * @return the ordered range of s c licenses 582 * @throws SystemException if a system exception occurred 583 */ 584 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCLicense> findAll( 585 int start, int end, 586 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 587 throws com.liferay.portal.kernel.exception.SystemException; 588 589 /** 590 * Removes all the s c licenses from the database. 591 * 592 * @throws SystemException if a system exception occurred 593 */ 594 public void removeAll() 595 throws com.liferay.portal.kernel.exception.SystemException; 596 597 /** 598 * Returns the number of s c licenses. 599 * 600 * @return the number of s c licenses 601 * @throws SystemException if a system exception occurred 602 */ 603 public int countAll() 604 throws com.liferay.portal.kernel.exception.SystemException; 605 606 /** 607 * Returns all the s c product entries associated with the s c license. 608 * 609 * @param pk the primary key of the s c license 610 * @return the s c product entries associated with the s c license 611 * @throws SystemException if a system exception occurred 612 */ 613 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> getSCProductEntries( 614 long pk) throws com.liferay.portal.kernel.exception.SystemException; 615 616 /** 617 * Returns a range of all the s c product entries associated with the s c license. 618 * 619 * <p> 620 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCLicenseModelImpl}. 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. 621 * </p> 622 * 623 * @param pk the primary key of the s c license 624 * @param start the lower bound of the range of s c licenses 625 * @param end the upper bound of the range of s c licenses (not inclusive) 626 * @return the range of s c product entries associated with the s c license 627 * @throws SystemException if a system exception occurred 628 */ 629 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> getSCProductEntries( 630 long pk, int start, int end) 631 throws com.liferay.portal.kernel.exception.SystemException; 632 633 /** 634 * Returns an ordered range of all the s c product entries associated with the s c license. 635 * 636 * <p> 637 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portlet.softwarecatalog.model.impl.SCLicenseModelImpl}. 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. 638 * </p> 639 * 640 * @param pk the primary key of the s c license 641 * @param start the lower bound of the range of s c licenses 642 * @param end the upper bound of the range of s c licenses (not inclusive) 643 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 644 * @return the ordered range of s c product entries associated with the s c license 645 * @throws SystemException if a system exception occurred 646 */ 647 public java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> getSCProductEntries( 648 long pk, int start, int end, 649 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 650 throws com.liferay.portal.kernel.exception.SystemException; 651 652 /** 653 * Returns the number of s c product entries associated with the s c license. 654 * 655 * @param pk the primary key of the s c license 656 * @return the number of s c product entries associated with the s c license 657 * @throws SystemException if a system exception occurred 658 */ 659 public int getSCProductEntriesSize(long pk) 660 throws com.liferay.portal.kernel.exception.SystemException; 661 662 /** 663 * Returns <code>true</code> if the s c product entry is associated with the s c license. 664 * 665 * @param pk the primary key of the s c license 666 * @param scProductEntryPK the primary key of the s c product entry 667 * @return <code>true</code> if the s c product entry is associated with the s c license; <code>false</code> otherwise 668 * @throws SystemException if a system exception occurred 669 */ 670 public boolean containsSCProductEntry(long pk, long scProductEntryPK) 671 throws com.liferay.portal.kernel.exception.SystemException; 672 673 /** 674 * Returns <code>true</code> if the s c license has any s c product entries associated with it. 675 * 676 * @param pk the primary key of the s c license to check for associations with s c product entries 677 * @return <code>true</code> if the s c license has any s c product entries associated with it; <code>false</code> otherwise 678 * @throws SystemException if a system exception occurred 679 */ 680 public boolean containsSCProductEntries(long pk) 681 throws com.liferay.portal.kernel.exception.SystemException; 682 683 /** 684 * Adds an association between the s c license and the s c product entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 685 * 686 * @param pk the primary key of the s c license 687 * @param scProductEntryPK the primary key of the s c product entry 688 * @throws SystemException if a system exception occurred 689 */ 690 public void addSCProductEntry(long pk, long scProductEntryPK) 691 throws com.liferay.portal.kernel.exception.SystemException; 692 693 /** 694 * Adds an association between the s c license and the s c product entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 695 * 696 * @param pk the primary key of the s c license 697 * @param scProductEntry the s c product entry 698 * @throws SystemException if a system exception occurred 699 */ 700 public void addSCProductEntry(long pk, 701 com.liferay.portlet.softwarecatalog.model.SCProductEntry scProductEntry) 702 throws com.liferay.portal.kernel.exception.SystemException; 703 704 /** 705 * Adds an association between the s c license and the s c product entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 706 * 707 * @param pk the primary key of the s c license 708 * @param scProductEntryPKs the primary keys of the s c product entries 709 * @throws SystemException if a system exception occurred 710 */ 711 public void addSCProductEntries(long pk, long[] scProductEntryPKs) 712 throws com.liferay.portal.kernel.exception.SystemException; 713 714 /** 715 * Adds an association between the s c license and the s c product entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 716 * 717 * @param pk the primary key of the s c license 718 * @param scProductEntries the s c product entries 719 * @throws SystemException if a system exception occurred 720 */ 721 public void addSCProductEntries(long pk, 722 java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> scProductEntries) 723 throws com.liferay.portal.kernel.exception.SystemException; 724 725 /** 726 * Clears all associations between the s c license and its s c product entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 727 * 728 * @param pk the primary key of the s c license to clear the associated s c product entries from 729 * @throws SystemException if a system exception occurred 730 */ 731 public void clearSCProductEntries(long pk) 732 throws com.liferay.portal.kernel.exception.SystemException; 733 734 /** 735 * Removes the association between the s c license and the s c product entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 736 * 737 * @param pk the primary key of the s c license 738 * @param scProductEntryPK the primary key of the s c product entry 739 * @throws SystemException if a system exception occurred 740 */ 741 public void removeSCProductEntry(long pk, long scProductEntryPK) 742 throws com.liferay.portal.kernel.exception.SystemException; 743 744 /** 745 * Removes the association between the s c license and the s c product entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 746 * 747 * @param pk the primary key of the s c license 748 * @param scProductEntry the s c product entry 749 * @throws SystemException if a system exception occurred 750 */ 751 public void removeSCProductEntry(long pk, 752 com.liferay.portlet.softwarecatalog.model.SCProductEntry scProductEntry) 753 throws com.liferay.portal.kernel.exception.SystemException; 754 755 /** 756 * Removes the association between the s c license and the s c product entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 757 * 758 * @param pk the primary key of the s c license 759 * @param scProductEntryPKs the primary keys of the s c product entries 760 * @throws SystemException if a system exception occurred 761 */ 762 public void removeSCProductEntries(long pk, long[] scProductEntryPKs) 763 throws com.liferay.portal.kernel.exception.SystemException; 764 765 /** 766 * Removes the association between the s c license and the s c product entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 767 * 768 * @param pk the primary key of the s c license 769 * @param scProductEntries the s c product entries 770 * @throws SystemException if a system exception occurred 771 */ 772 public void removeSCProductEntries(long pk, 773 java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> scProductEntries) 774 throws com.liferay.portal.kernel.exception.SystemException; 775 776 /** 777 * Sets the s c product entries associated with the s c license, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 778 * 779 * @param pk the primary key of the s c license 780 * @param scProductEntryPKs the primary keys of the s c product entries to be associated with the s c license 781 * @throws SystemException if a system exception occurred 782 */ 783 public void setSCProductEntries(long pk, long[] scProductEntryPKs) 784 throws com.liferay.portal.kernel.exception.SystemException; 785 786 /** 787 * Sets the s c product entries associated with the s c license, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 788 * 789 * @param pk the primary key of the s c license 790 * @param scProductEntries the s c product entries to be associated with the s c license 791 * @throws SystemException if a system exception occurred 792 */ 793 public void setSCProductEntries(long pk, 794 java.util.List<com.liferay.portlet.softwarecatalog.model.SCProductEntry> scProductEntries) 795 throws com.liferay.portal.kernel.exception.SystemException; 796 }