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