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