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