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.asset.kernel.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.asset.kernel.exception.NoSuchCategoryException; 020 import com.liferay.asset.kernel.model.AssetCategory; 021 022 import com.liferay.portal.kernel.service.persistence.BasePersistence; 023 024 /** 025 * The persistence interface for the asset category service. 026 * 027 * <p> 028 * Caching information and settings can be found in <code>portal.properties</code> 029 * </p> 030 * 031 * @author Brian Wing Shun Chan 032 * @see com.liferay.portlet.asset.service.persistence.impl.AssetCategoryPersistenceImpl 033 * @see AssetCategoryUtil 034 * @generated 035 */ 036 @ProviderType 037 public interface AssetCategoryPersistence extends BasePersistence<AssetCategory> { 038 /* 039 * NOTE FOR DEVELOPERS: 040 * 041 * Never modify or reference this interface directly. Always use {@link AssetCategoryUtil} to access the asset category persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface. 042 */ 043 044 /** 045 * Returns all the asset categories where uuid = ?. 046 * 047 * @param uuid the uuid 048 * @return the matching asset categories 049 */ 050 public java.util.List<AssetCategory> findByUuid(java.lang.String uuid); 051 052 /** 053 * Returns a range of all the asset categories where uuid = ?. 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 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 AssetCategoryModelImpl}. 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 uuid the uuid 060 * @param start the lower bound of the range of asset categories 061 * @param end the upper bound of the range of asset categories (not inclusive) 062 * @return the range of matching asset categories 063 */ 064 public java.util.List<AssetCategory> findByUuid(java.lang.String uuid, 065 int start, int end); 066 067 /** 068 * Returns an ordered range of all the asset categories where uuid = ?. 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 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 AssetCategoryModelImpl}. 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 uuid the uuid 075 * @param start the lower bound of the range of asset categories 076 * @param end the upper bound of the range of asset categories (not inclusive) 077 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 078 * @return the ordered range of matching asset categories 079 */ 080 public java.util.List<AssetCategory> findByUuid(java.lang.String uuid, 081 int start, int end, 082 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 083 084 /** 085 * Returns an ordered range of all the asset categories where uuid = ?. 086 * 087 * <p> 088 * 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 AssetCategoryModelImpl}. 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. 089 * </p> 090 * 091 * @param uuid the uuid 092 * @param start the lower bound of the range of asset categories 093 * @param end the upper bound of the range of asset categories (not inclusive) 094 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 095 * @param retrieveFromCache whether to retrieve from the finder cache 096 * @return the ordered range of matching asset categories 097 */ 098 public java.util.List<AssetCategory> findByUuid(java.lang.String uuid, 099 int start, int end, 100 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator, 101 boolean retrieveFromCache); 102 103 /** 104 * Returns the first asset category in the ordered set where uuid = ?. 105 * 106 * @param uuid the uuid 107 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 108 * @return the first matching asset category 109 * @throws NoSuchCategoryException if a matching asset category could not be found 110 */ 111 public AssetCategory findByUuid_First(java.lang.String uuid, 112 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 113 throws NoSuchCategoryException; 114 115 /** 116 * Returns the first asset category in the ordered set where uuid = ?. 117 * 118 * @param uuid the uuid 119 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 120 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 121 */ 122 public AssetCategory fetchByUuid_First(java.lang.String uuid, 123 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 124 125 /** 126 * Returns the last asset category in the ordered set where uuid = ?. 127 * 128 * @param uuid the uuid 129 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 130 * @return the last matching asset category 131 * @throws NoSuchCategoryException if a matching asset category could not be found 132 */ 133 public AssetCategory findByUuid_Last(java.lang.String uuid, 134 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 135 throws NoSuchCategoryException; 136 137 /** 138 * Returns the last asset category in the ordered set where uuid = ?. 139 * 140 * @param uuid the uuid 141 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 142 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 143 */ 144 public AssetCategory fetchByUuid_Last(java.lang.String uuid, 145 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 146 147 /** 148 * Returns the asset categories before and after the current asset category in the ordered set where uuid = ?. 149 * 150 * @param categoryId the primary key of the current asset category 151 * @param uuid the uuid 152 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 153 * @return the previous, current, and next asset category 154 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 155 */ 156 public AssetCategory[] findByUuid_PrevAndNext(long categoryId, 157 java.lang.String uuid, 158 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 159 throws NoSuchCategoryException; 160 161 /** 162 * Removes all the asset categories where uuid = ? from the database. 163 * 164 * @param uuid the uuid 165 */ 166 public void removeByUuid(java.lang.String uuid); 167 168 /** 169 * Returns the number of asset categories where uuid = ?. 170 * 171 * @param uuid the uuid 172 * @return the number of matching asset categories 173 */ 174 public int countByUuid(java.lang.String uuid); 175 176 /** 177 * Returns the asset category where uuid = ? and groupId = ? or throws a {@link NoSuchCategoryException} if it could not be found. 178 * 179 * @param uuid the uuid 180 * @param groupId the group ID 181 * @return the matching asset category 182 * @throws NoSuchCategoryException if a matching asset category could not be found 183 */ 184 public AssetCategory findByUUID_G(java.lang.String uuid, long groupId) 185 throws NoSuchCategoryException; 186 187 /** 188 * Returns the asset category where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 189 * 190 * @param uuid the uuid 191 * @param groupId the group ID 192 * @return the matching asset category, or <code>null</code> if a matching asset category could not be found 193 */ 194 public AssetCategory fetchByUUID_G(java.lang.String uuid, long groupId); 195 196 /** 197 * Returns the asset category where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 198 * 199 * @param uuid the uuid 200 * @param groupId the group ID 201 * @param retrieveFromCache whether to retrieve from the finder cache 202 * @return the matching asset category, or <code>null</code> if a matching asset category could not be found 203 */ 204 public AssetCategory fetchByUUID_G(java.lang.String uuid, long groupId, 205 boolean retrieveFromCache); 206 207 /** 208 * Removes the asset category where uuid = ? and groupId = ? from the database. 209 * 210 * @param uuid the uuid 211 * @param groupId the group ID 212 * @return the asset category that was removed 213 */ 214 public AssetCategory removeByUUID_G(java.lang.String uuid, long groupId) 215 throws NoSuchCategoryException; 216 217 /** 218 * Returns the number of asset categories where uuid = ? and groupId = ?. 219 * 220 * @param uuid the uuid 221 * @param groupId the group ID 222 * @return the number of matching asset categories 223 */ 224 public int countByUUID_G(java.lang.String uuid, long groupId); 225 226 /** 227 * Returns all the asset categories where uuid = ? and companyId = ?. 228 * 229 * @param uuid the uuid 230 * @param companyId the company ID 231 * @return the matching asset categories 232 */ 233 public java.util.List<AssetCategory> findByUuid_C(java.lang.String uuid, 234 long companyId); 235 236 /** 237 * Returns a range of all the asset categories where uuid = ? and companyId = ?. 238 * 239 * <p> 240 * 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 AssetCategoryModelImpl}. 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. 241 * </p> 242 * 243 * @param uuid the uuid 244 * @param companyId the company ID 245 * @param start the lower bound of the range of asset categories 246 * @param end the upper bound of the range of asset categories (not inclusive) 247 * @return the range of matching asset categories 248 */ 249 public java.util.List<AssetCategory> findByUuid_C(java.lang.String uuid, 250 long companyId, int start, int end); 251 252 /** 253 * Returns an ordered range of all the asset categories where uuid = ? and companyId = ?. 254 * 255 * <p> 256 * 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 AssetCategoryModelImpl}. 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. 257 * </p> 258 * 259 * @param uuid the uuid 260 * @param companyId the company ID 261 * @param start the lower bound of the range of asset categories 262 * @param end the upper bound of the range of asset categories (not inclusive) 263 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 264 * @return the ordered range of matching asset categories 265 */ 266 public java.util.List<AssetCategory> findByUuid_C(java.lang.String uuid, 267 long companyId, int start, int end, 268 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 269 270 /** 271 * Returns an ordered range of all the asset categories where uuid = ? and companyId = ?. 272 * 273 * <p> 274 * 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 AssetCategoryModelImpl}. 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. 275 * </p> 276 * 277 * @param uuid the uuid 278 * @param companyId the company ID 279 * @param start the lower bound of the range of asset categories 280 * @param end the upper bound of the range of asset categories (not inclusive) 281 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 282 * @param retrieveFromCache whether to retrieve from the finder cache 283 * @return the ordered range of matching asset categories 284 */ 285 public java.util.List<AssetCategory> findByUuid_C(java.lang.String uuid, 286 long companyId, int start, int end, 287 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator, 288 boolean retrieveFromCache); 289 290 /** 291 * Returns the first asset category in the ordered set where uuid = ? and companyId = ?. 292 * 293 * @param uuid the uuid 294 * @param companyId the company ID 295 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 296 * @return the first matching asset category 297 * @throws NoSuchCategoryException if a matching asset category could not be found 298 */ 299 public AssetCategory findByUuid_C_First(java.lang.String uuid, 300 long companyId, 301 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 302 throws NoSuchCategoryException; 303 304 /** 305 * Returns the first asset category in the ordered set where uuid = ? and companyId = ?. 306 * 307 * @param uuid the uuid 308 * @param companyId the company ID 309 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 310 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 311 */ 312 public AssetCategory fetchByUuid_C_First(java.lang.String uuid, 313 long companyId, 314 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 315 316 /** 317 * Returns the last asset category in the ordered set where uuid = ? and companyId = ?. 318 * 319 * @param uuid the uuid 320 * @param companyId the company ID 321 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 322 * @return the last matching asset category 323 * @throws NoSuchCategoryException if a matching asset category could not be found 324 */ 325 public AssetCategory findByUuid_C_Last(java.lang.String uuid, 326 long companyId, 327 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 328 throws NoSuchCategoryException; 329 330 /** 331 * Returns the last asset category in the ordered set where uuid = ? and companyId = ?. 332 * 333 * @param uuid the uuid 334 * @param companyId the company ID 335 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 336 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 337 */ 338 public AssetCategory fetchByUuid_C_Last(java.lang.String uuid, 339 long companyId, 340 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 341 342 /** 343 * Returns the asset categories before and after the current asset category in the ordered set where uuid = ? and companyId = ?. 344 * 345 * @param categoryId the primary key of the current asset category 346 * @param uuid the uuid 347 * @param companyId the company ID 348 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 349 * @return the previous, current, and next asset category 350 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 351 */ 352 public AssetCategory[] findByUuid_C_PrevAndNext(long categoryId, 353 java.lang.String uuid, long companyId, 354 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 355 throws NoSuchCategoryException; 356 357 /** 358 * Removes all the asset categories where uuid = ? and companyId = ? from the database. 359 * 360 * @param uuid the uuid 361 * @param companyId the company ID 362 */ 363 public void removeByUuid_C(java.lang.String uuid, long companyId); 364 365 /** 366 * Returns the number of asset categories where uuid = ? and companyId = ?. 367 * 368 * @param uuid the uuid 369 * @param companyId the company ID 370 * @return the number of matching asset categories 371 */ 372 public int countByUuid_C(java.lang.String uuid, long companyId); 373 374 /** 375 * Returns all the asset categories where groupId = ?. 376 * 377 * @param groupId the group ID 378 * @return the matching asset categories 379 */ 380 public java.util.List<AssetCategory> findByGroupId(long groupId); 381 382 /** 383 * Returns a range of all the asset categories where groupId = ?. 384 * 385 * <p> 386 * 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 AssetCategoryModelImpl}. 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. 387 * </p> 388 * 389 * @param groupId the group ID 390 * @param start the lower bound of the range of asset categories 391 * @param end the upper bound of the range of asset categories (not inclusive) 392 * @return the range of matching asset categories 393 */ 394 public java.util.List<AssetCategory> findByGroupId(long groupId, int start, 395 int end); 396 397 /** 398 * Returns an ordered range of all the asset categories where groupId = ?. 399 * 400 * <p> 401 * 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 AssetCategoryModelImpl}. 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. 402 * </p> 403 * 404 * @param groupId the group ID 405 * @param start the lower bound of the range of asset categories 406 * @param end the upper bound of the range of asset categories (not inclusive) 407 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 408 * @return the ordered range of matching asset categories 409 */ 410 public java.util.List<AssetCategory> findByGroupId(long groupId, int start, 411 int end, 412 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 413 414 /** 415 * Returns an ordered range of all the asset categories where groupId = ?. 416 * 417 * <p> 418 * 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 AssetCategoryModelImpl}. 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. 419 * </p> 420 * 421 * @param groupId the group ID 422 * @param start the lower bound of the range of asset categories 423 * @param end the upper bound of the range of asset categories (not inclusive) 424 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 425 * @param retrieveFromCache whether to retrieve from the finder cache 426 * @return the ordered range of matching asset categories 427 */ 428 public java.util.List<AssetCategory> findByGroupId(long groupId, int start, 429 int end, 430 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator, 431 boolean retrieveFromCache); 432 433 /** 434 * Returns the first asset category in the ordered set where groupId = ?. 435 * 436 * @param groupId the group ID 437 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 438 * @return the first matching asset category 439 * @throws NoSuchCategoryException if a matching asset category could not be found 440 */ 441 public AssetCategory findByGroupId_First(long groupId, 442 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 443 throws NoSuchCategoryException; 444 445 /** 446 * Returns the first asset category in the ordered set where groupId = ?. 447 * 448 * @param groupId the group ID 449 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 450 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 451 */ 452 public AssetCategory fetchByGroupId_First(long groupId, 453 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 454 455 /** 456 * Returns the last asset category in the ordered set where groupId = ?. 457 * 458 * @param groupId the group ID 459 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 460 * @return the last matching asset category 461 * @throws NoSuchCategoryException if a matching asset category could not be found 462 */ 463 public AssetCategory findByGroupId_Last(long groupId, 464 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 465 throws NoSuchCategoryException; 466 467 /** 468 * Returns the last asset category in the ordered set where groupId = ?. 469 * 470 * @param groupId the group ID 471 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 472 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 473 */ 474 public AssetCategory fetchByGroupId_Last(long groupId, 475 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 476 477 /** 478 * Returns the asset categories before and after the current asset category in the ordered set where groupId = ?. 479 * 480 * @param categoryId the primary key of the current asset category 481 * @param groupId the group ID 482 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 483 * @return the previous, current, and next asset category 484 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 485 */ 486 public AssetCategory[] findByGroupId_PrevAndNext(long categoryId, 487 long groupId, 488 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 489 throws NoSuchCategoryException; 490 491 /** 492 * Returns all the asset categories that the user has permission to view where groupId = ?. 493 * 494 * @param groupId the group ID 495 * @return the matching asset categories that the user has permission to view 496 */ 497 public java.util.List<AssetCategory> filterFindByGroupId(long groupId); 498 499 /** 500 * Returns a range of all the asset categories that the user has permission to view where groupId = ?. 501 * 502 * <p> 503 * 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 AssetCategoryModelImpl}. 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. 504 * </p> 505 * 506 * @param groupId the group ID 507 * @param start the lower bound of the range of asset categories 508 * @param end the upper bound of the range of asset categories (not inclusive) 509 * @return the range of matching asset categories that the user has permission to view 510 */ 511 public java.util.List<AssetCategory> filterFindByGroupId(long groupId, 512 int start, int end); 513 514 /** 515 * Returns an ordered range of all the asset categories that the user has permissions to view where groupId = ?. 516 * 517 * <p> 518 * 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 AssetCategoryModelImpl}. 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. 519 * </p> 520 * 521 * @param groupId the group ID 522 * @param start the lower bound of the range of asset categories 523 * @param end the upper bound of the range of asset categories (not inclusive) 524 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 525 * @return the ordered range of matching asset categories that the user has permission to view 526 */ 527 public java.util.List<AssetCategory> filterFindByGroupId(long groupId, 528 int start, int end, 529 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 530 531 /** 532 * Returns the asset categories before and after the current asset category in the ordered set of asset categories that the user has permission to view where groupId = ?. 533 * 534 * @param categoryId the primary key of the current asset category 535 * @param groupId the group ID 536 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 537 * @return the previous, current, and next asset category 538 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 539 */ 540 public AssetCategory[] filterFindByGroupId_PrevAndNext(long categoryId, 541 long groupId, 542 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 543 throws NoSuchCategoryException; 544 545 /** 546 * Removes all the asset categories where groupId = ? from the database. 547 * 548 * @param groupId the group ID 549 */ 550 public void removeByGroupId(long groupId); 551 552 /** 553 * Returns the number of asset categories where groupId = ?. 554 * 555 * @param groupId the group ID 556 * @return the number of matching asset categories 557 */ 558 public int countByGroupId(long groupId); 559 560 /** 561 * Returns the number of asset categories that the user has permission to view where groupId = ?. 562 * 563 * @param groupId the group ID 564 * @return the number of matching asset categories that the user has permission to view 565 */ 566 public int filterCountByGroupId(long groupId); 567 568 /** 569 * Returns all the asset categories where parentCategoryId = ?. 570 * 571 * @param parentCategoryId the parent category ID 572 * @return the matching asset categories 573 */ 574 public java.util.List<AssetCategory> findByParentCategoryId( 575 long parentCategoryId); 576 577 /** 578 * Returns a range of all the asset categories where parentCategoryId = ?. 579 * 580 * <p> 581 * 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 AssetCategoryModelImpl}. 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. 582 * </p> 583 * 584 * @param parentCategoryId the parent category ID 585 * @param start the lower bound of the range of asset categories 586 * @param end the upper bound of the range of asset categories (not inclusive) 587 * @return the range of matching asset categories 588 */ 589 public java.util.List<AssetCategory> findByParentCategoryId( 590 long parentCategoryId, int start, int end); 591 592 /** 593 * Returns an ordered range of all the asset categories where parentCategoryId = ?. 594 * 595 * <p> 596 * 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 AssetCategoryModelImpl}. 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. 597 * </p> 598 * 599 * @param parentCategoryId the parent category ID 600 * @param start the lower bound of the range of asset categories 601 * @param end the upper bound of the range of asset categories (not inclusive) 602 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 603 * @return the ordered range of matching asset categories 604 */ 605 public java.util.List<AssetCategory> findByParentCategoryId( 606 long parentCategoryId, int start, int end, 607 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 608 609 /** 610 * Returns an ordered range of all the asset categories where parentCategoryId = ?. 611 * 612 * <p> 613 * 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 AssetCategoryModelImpl}. 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. 614 * </p> 615 * 616 * @param parentCategoryId the parent category ID 617 * @param start the lower bound of the range of asset categories 618 * @param end the upper bound of the range of asset categories (not inclusive) 619 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 620 * @param retrieveFromCache whether to retrieve from the finder cache 621 * @return the ordered range of matching asset categories 622 */ 623 public java.util.List<AssetCategory> findByParentCategoryId( 624 long parentCategoryId, int start, int end, 625 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator, 626 boolean retrieveFromCache); 627 628 /** 629 * Returns the first asset category in the ordered set where parentCategoryId = ?. 630 * 631 * @param parentCategoryId the parent category ID 632 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 633 * @return the first matching asset category 634 * @throws NoSuchCategoryException if a matching asset category could not be found 635 */ 636 public AssetCategory findByParentCategoryId_First(long parentCategoryId, 637 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 638 throws NoSuchCategoryException; 639 640 /** 641 * Returns the first asset category in the ordered set where parentCategoryId = ?. 642 * 643 * @param parentCategoryId the parent category ID 644 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 645 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 646 */ 647 public AssetCategory fetchByParentCategoryId_First(long parentCategoryId, 648 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 649 650 /** 651 * Returns the last asset category in the ordered set where parentCategoryId = ?. 652 * 653 * @param parentCategoryId the parent category ID 654 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 655 * @return the last matching asset category 656 * @throws NoSuchCategoryException if a matching asset category could not be found 657 */ 658 public AssetCategory findByParentCategoryId_Last(long parentCategoryId, 659 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 660 throws NoSuchCategoryException; 661 662 /** 663 * Returns the last asset category in the ordered set where parentCategoryId = ?. 664 * 665 * @param parentCategoryId the parent category ID 666 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 667 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 668 */ 669 public AssetCategory fetchByParentCategoryId_Last(long parentCategoryId, 670 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 671 672 /** 673 * Returns the asset categories before and after the current asset category in the ordered set where parentCategoryId = ?. 674 * 675 * @param categoryId the primary key of the current asset category 676 * @param parentCategoryId the parent category ID 677 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 678 * @return the previous, current, and next asset category 679 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 680 */ 681 public AssetCategory[] findByParentCategoryId_PrevAndNext(long categoryId, 682 long parentCategoryId, 683 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 684 throws NoSuchCategoryException; 685 686 /** 687 * Removes all the asset categories where parentCategoryId = ? from the database. 688 * 689 * @param parentCategoryId the parent category ID 690 */ 691 public void removeByParentCategoryId(long parentCategoryId); 692 693 /** 694 * Returns the number of asset categories where parentCategoryId = ?. 695 * 696 * @param parentCategoryId the parent category ID 697 * @return the number of matching asset categories 698 */ 699 public int countByParentCategoryId(long parentCategoryId); 700 701 /** 702 * Returns all the asset categories where vocabularyId = ?. 703 * 704 * @param vocabularyId the vocabulary ID 705 * @return the matching asset categories 706 */ 707 public java.util.List<AssetCategory> findByVocabularyId(long vocabularyId); 708 709 /** 710 * Returns a range of all the asset categories where vocabularyId = ?. 711 * 712 * <p> 713 * 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 AssetCategoryModelImpl}. 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. 714 * </p> 715 * 716 * @param vocabularyId the vocabulary ID 717 * @param start the lower bound of the range of asset categories 718 * @param end the upper bound of the range of asset categories (not inclusive) 719 * @return the range of matching asset categories 720 */ 721 public java.util.List<AssetCategory> findByVocabularyId(long vocabularyId, 722 int start, int end); 723 724 /** 725 * Returns an ordered range of all the asset categories where vocabularyId = ?. 726 * 727 * <p> 728 * 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 AssetCategoryModelImpl}. 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. 729 * </p> 730 * 731 * @param vocabularyId the vocabulary ID 732 * @param start the lower bound of the range of asset categories 733 * @param end the upper bound of the range of asset categories (not inclusive) 734 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 735 * @return the ordered range of matching asset categories 736 */ 737 public java.util.List<AssetCategory> findByVocabularyId(long vocabularyId, 738 int start, int end, 739 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 740 741 /** 742 * Returns an ordered range of all the asset categories where vocabularyId = ?. 743 * 744 * <p> 745 * 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 AssetCategoryModelImpl}. 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. 746 * </p> 747 * 748 * @param vocabularyId the vocabulary ID 749 * @param start the lower bound of the range of asset categories 750 * @param end the upper bound of the range of asset categories (not inclusive) 751 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 752 * @param retrieveFromCache whether to retrieve from the finder cache 753 * @return the ordered range of matching asset categories 754 */ 755 public java.util.List<AssetCategory> findByVocabularyId(long vocabularyId, 756 int start, int end, 757 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator, 758 boolean retrieveFromCache); 759 760 /** 761 * Returns the first asset category in the ordered set where vocabularyId = ?. 762 * 763 * @param vocabularyId the vocabulary ID 764 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 765 * @return the first matching asset category 766 * @throws NoSuchCategoryException if a matching asset category could not be found 767 */ 768 public AssetCategory findByVocabularyId_First(long vocabularyId, 769 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 770 throws NoSuchCategoryException; 771 772 /** 773 * Returns the first asset category in the ordered set where vocabularyId = ?. 774 * 775 * @param vocabularyId the vocabulary ID 776 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 777 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 778 */ 779 public AssetCategory fetchByVocabularyId_First(long vocabularyId, 780 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 781 782 /** 783 * Returns the last asset category in the ordered set where vocabularyId = ?. 784 * 785 * @param vocabularyId the vocabulary ID 786 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 787 * @return the last matching asset category 788 * @throws NoSuchCategoryException if a matching asset category could not be found 789 */ 790 public AssetCategory findByVocabularyId_Last(long vocabularyId, 791 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 792 throws NoSuchCategoryException; 793 794 /** 795 * Returns the last asset category in the ordered set where vocabularyId = ?. 796 * 797 * @param vocabularyId the vocabulary ID 798 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 799 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 800 */ 801 public AssetCategory fetchByVocabularyId_Last(long vocabularyId, 802 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 803 804 /** 805 * Returns the asset categories before and after the current asset category in the ordered set where vocabularyId = ?. 806 * 807 * @param categoryId the primary key of the current asset category 808 * @param vocabularyId the vocabulary ID 809 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 810 * @return the previous, current, and next asset category 811 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 812 */ 813 public AssetCategory[] findByVocabularyId_PrevAndNext(long categoryId, 814 long vocabularyId, 815 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 816 throws NoSuchCategoryException; 817 818 /** 819 * Removes all the asset categories where vocabularyId = ? from the database. 820 * 821 * @param vocabularyId the vocabulary ID 822 */ 823 public void removeByVocabularyId(long vocabularyId); 824 825 /** 826 * Returns the number of asset categories where vocabularyId = ?. 827 * 828 * @param vocabularyId the vocabulary ID 829 * @return the number of matching asset categories 830 */ 831 public int countByVocabularyId(long vocabularyId); 832 833 /** 834 * Returns all the asset categories where groupId = ? and vocabularyId = ?. 835 * 836 * @param groupId the group ID 837 * @param vocabularyId the vocabulary ID 838 * @return the matching asset categories 839 */ 840 public java.util.List<AssetCategory> findByG_V(long groupId, 841 long vocabularyId); 842 843 /** 844 * Returns a range of all the asset categories where groupId = ? and vocabularyId = ?. 845 * 846 * <p> 847 * 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 AssetCategoryModelImpl}. 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. 848 * </p> 849 * 850 * @param groupId the group ID 851 * @param vocabularyId the vocabulary ID 852 * @param start the lower bound of the range of asset categories 853 * @param end the upper bound of the range of asset categories (not inclusive) 854 * @return the range of matching asset categories 855 */ 856 public java.util.List<AssetCategory> findByG_V(long groupId, 857 long vocabularyId, int start, int end); 858 859 /** 860 * Returns an ordered range of all the asset categories where groupId = ? and vocabularyId = ?. 861 * 862 * <p> 863 * 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 AssetCategoryModelImpl}. 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. 864 * </p> 865 * 866 * @param groupId the group ID 867 * @param vocabularyId the vocabulary ID 868 * @param start the lower bound of the range of asset categories 869 * @param end the upper bound of the range of asset categories (not inclusive) 870 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 871 * @return the ordered range of matching asset categories 872 */ 873 public java.util.List<AssetCategory> findByG_V(long groupId, 874 long vocabularyId, int start, int end, 875 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 876 877 /** 878 * Returns an ordered range of all the asset categories where groupId = ? and vocabularyId = ?. 879 * 880 * <p> 881 * 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 AssetCategoryModelImpl}. 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. 882 * </p> 883 * 884 * @param groupId the group ID 885 * @param vocabularyId the vocabulary ID 886 * @param start the lower bound of the range of asset categories 887 * @param end the upper bound of the range of asset categories (not inclusive) 888 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 889 * @param retrieveFromCache whether to retrieve from the finder cache 890 * @return the ordered range of matching asset categories 891 */ 892 public java.util.List<AssetCategory> findByG_V(long groupId, 893 long vocabularyId, int start, int end, 894 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator, 895 boolean retrieveFromCache); 896 897 /** 898 * Returns the first asset category in the ordered set where groupId = ? and vocabularyId = ?. 899 * 900 * @param groupId the group ID 901 * @param vocabularyId the vocabulary ID 902 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 903 * @return the first matching asset category 904 * @throws NoSuchCategoryException if a matching asset category could not be found 905 */ 906 public AssetCategory findByG_V_First(long groupId, long vocabularyId, 907 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 908 throws NoSuchCategoryException; 909 910 /** 911 * Returns the first asset category in the ordered set where groupId = ? and vocabularyId = ?. 912 * 913 * @param groupId the group ID 914 * @param vocabularyId the vocabulary ID 915 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 916 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 917 */ 918 public AssetCategory fetchByG_V_First(long groupId, long vocabularyId, 919 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 920 921 /** 922 * Returns the last asset category in the ordered set where groupId = ? and vocabularyId = ?. 923 * 924 * @param groupId the group ID 925 * @param vocabularyId the vocabulary ID 926 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 927 * @return the last matching asset category 928 * @throws NoSuchCategoryException if a matching asset category could not be found 929 */ 930 public AssetCategory findByG_V_Last(long groupId, long vocabularyId, 931 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 932 throws NoSuchCategoryException; 933 934 /** 935 * Returns the last asset category in the ordered set where groupId = ? and vocabularyId = ?. 936 * 937 * @param groupId the group ID 938 * @param vocabularyId the vocabulary ID 939 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 940 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 941 */ 942 public AssetCategory fetchByG_V_Last(long groupId, long vocabularyId, 943 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 944 945 /** 946 * Returns the asset categories before and after the current asset category in the ordered set where groupId = ? and vocabularyId = ?. 947 * 948 * @param categoryId the primary key of the current asset category 949 * @param groupId the group ID 950 * @param vocabularyId the vocabulary ID 951 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 952 * @return the previous, current, and next asset category 953 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 954 */ 955 public AssetCategory[] findByG_V_PrevAndNext(long categoryId, long groupId, 956 long vocabularyId, 957 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 958 throws NoSuchCategoryException; 959 960 /** 961 * Returns all the asset categories that the user has permission to view where groupId = ? and vocabularyId = ?. 962 * 963 * @param groupId the group ID 964 * @param vocabularyId the vocabulary ID 965 * @return the matching asset categories that the user has permission to view 966 */ 967 public java.util.List<AssetCategory> filterFindByG_V(long groupId, 968 long vocabularyId); 969 970 /** 971 * Returns a range of all the asset categories that the user has permission to view where groupId = ? and vocabularyId = ?. 972 * 973 * <p> 974 * 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 AssetCategoryModelImpl}. 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. 975 * </p> 976 * 977 * @param groupId the group ID 978 * @param vocabularyId the vocabulary ID 979 * @param start the lower bound of the range of asset categories 980 * @param end the upper bound of the range of asset categories (not inclusive) 981 * @return the range of matching asset categories that the user has permission to view 982 */ 983 public java.util.List<AssetCategory> filterFindByG_V(long groupId, 984 long vocabularyId, int start, int end); 985 986 /** 987 * Returns an ordered range of all the asset categories that the user has permissions to view where groupId = ? and vocabularyId = ?. 988 * 989 * <p> 990 * 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 AssetCategoryModelImpl}. 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. 991 * </p> 992 * 993 * @param groupId the group ID 994 * @param vocabularyId the vocabulary ID 995 * @param start the lower bound of the range of asset categories 996 * @param end the upper bound of the range of asset categories (not inclusive) 997 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 998 * @return the ordered range of matching asset categories that the user has permission to view 999 */ 1000 public java.util.List<AssetCategory> filterFindByG_V(long groupId, 1001 long vocabularyId, int start, int end, 1002 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1003 1004 /** 1005 * Returns the asset categories before and after the current asset category in the ordered set of asset categories that the user has permission to view where groupId = ? and vocabularyId = ?. 1006 * 1007 * @param categoryId the primary key of the current asset category 1008 * @param groupId the group ID 1009 * @param vocabularyId the vocabulary ID 1010 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1011 * @return the previous, current, and next asset category 1012 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 1013 */ 1014 public AssetCategory[] filterFindByG_V_PrevAndNext(long categoryId, 1015 long groupId, long vocabularyId, 1016 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 1017 throws NoSuchCategoryException; 1018 1019 /** 1020 * Returns all the asset categories that the user has permission to view where groupId = ? and vocabularyId = any ?. 1021 * 1022 * @param groupId the group ID 1023 * @param vocabularyIds the vocabulary IDs 1024 * @return the matching asset categories that the user has permission to view 1025 */ 1026 public java.util.List<AssetCategory> filterFindByG_V(long groupId, 1027 long[] vocabularyIds); 1028 1029 /** 1030 * Returns a range of all the asset categories that the user has permission to view where groupId = ? and vocabularyId = any ?. 1031 * 1032 * <p> 1033 * 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 AssetCategoryModelImpl}. 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. 1034 * </p> 1035 * 1036 * @param groupId the group ID 1037 * @param vocabularyIds the vocabulary IDs 1038 * @param start the lower bound of the range of asset categories 1039 * @param end the upper bound of the range of asset categories (not inclusive) 1040 * @return the range of matching asset categories that the user has permission to view 1041 */ 1042 public java.util.List<AssetCategory> filterFindByG_V(long groupId, 1043 long[] vocabularyIds, int start, int end); 1044 1045 /** 1046 * Returns an ordered range of all the asset categories that the user has permission to view where groupId = ? and vocabularyId = any ?. 1047 * 1048 * <p> 1049 * 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 AssetCategoryModelImpl}. 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. 1050 * </p> 1051 * 1052 * @param groupId the group ID 1053 * @param vocabularyIds the vocabulary IDs 1054 * @param start the lower bound of the range of asset categories 1055 * @param end the upper bound of the range of asset categories (not inclusive) 1056 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1057 * @return the ordered range of matching asset categories that the user has permission to view 1058 */ 1059 public java.util.List<AssetCategory> filterFindByG_V(long groupId, 1060 long[] vocabularyIds, int start, int end, 1061 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1062 1063 /** 1064 * Returns all the asset categories where groupId = ? and vocabularyId = any ?. 1065 * 1066 * <p> 1067 * 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 AssetCategoryModelImpl}. 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. 1068 * </p> 1069 * 1070 * @param groupId the group ID 1071 * @param vocabularyIds the vocabulary IDs 1072 * @return the matching asset categories 1073 */ 1074 public java.util.List<AssetCategory> findByG_V(long groupId, 1075 long[] vocabularyIds); 1076 1077 /** 1078 * Returns a range of all the asset categories where groupId = ? and vocabularyId = any ?. 1079 * 1080 * <p> 1081 * 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 AssetCategoryModelImpl}. 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. 1082 * </p> 1083 * 1084 * @param groupId the group ID 1085 * @param vocabularyIds the vocabulary IDs 1086 * @param start the lower bound of the range of asset categories 1087 * @param end the upper bound of the range of asset categories (not inclusive) 1088 * @return the range of matching asset categories 1089 */ 1090 public java.util.List<AssetCategory> findByG_V(long groupId, 1091 long[] vocabularyIds, int start, int end); 1092 1093 /** 1094 * Returns an ordered range of all the asset categories where groupId = ? and vocabularyId = any ?. 1095 * 1096 * <p> 1097 * 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 AssetCategoryModelImpl}. 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. 1098 * </p> 1099 * 1100 * @param groupId the group ID 1101 * @param vocabularyIds the vocabulary IDs 1102 * @param start the lower bound of the range of asset categories 1103 * @param end the upper bound of the range of asset categories (not inclusive) 1104 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1105 * @return the ordered range of matching asset categories 1106 */ 1107 public java.util.List<AssetCategory> findByG_V(long groupId, 1108 long[] vocabularyIds, int start, int end, 1109 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1110 1111 /** 1112 * Returns an ordered range of all the asset categories where groupId = ? and vocabularyId = ?, optionally using the finder cache. 1113 * 1114 * <p> 1115 * 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 AssetCategoryModelImpl}. 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. 1116 * </p> 1117 * 1118 * @param groupId the group ID 1119 * @param vocabularyId the vocabulary ID 1120 * @param start the lower bound of the range of asset categories 1121 * @param end the upper bound of the range of asset categories (not inclusive) 1122 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1123 * @param retrieveFromCache whether to retrieve from the finder cache 1124 * @return the ordered range of matching asset categories 1125 */ 1126 public java.util.List<AssetCategory> findByG_V(long groupId, 1127 long[] vocabularyIds, int start, int end, 1128 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator, 1129 boolean retrieveFromCache); 1130 1131 /** 1132 * Removes all the asset categories where groupId = ? and vocabularyId = ? from the database. 1133 * 1134 * @param groupId the group ID 1135 * @param vocabularyId the vocabulary ID 1136 */ 1137 public void removeByG_V(long groupId, long vocabularyId); 1138 1139 /** 1140 * Returns the number of asset categories where groupId = ? and vocabularyId = ?. 1141 * 1142 * @param groupId the group ID 1143 * @param vocabularyId the vocabulary ID 1144 * @return the number of matching asset categories 1145 */ 1146 public int countByG_V(long groupId, long vocabularyId); 1147 1148 /** 1149 * Returns the number of asset categories where groupId = ? and vocabularyId = any ?. 1150 * 1151 * @param groupId the group ID 1152 * @param vocabularyIds the vocabulary IDs 1153 * @return the number of matching asset categories 1154 */ 1155 public int countByG_V(long groupId, long[] vocabularyIds); 1156 1157 /** 1158 * Returns the number of asset categories that the user has permission to view where groupId = ? and vocabularyId = ?. 1159 * 1160 * @param groupId the group ID 1161 * @param vocabularyId the vocabulary ID 1162 * @return the number of matching asset categories that the user has permission to view 1163 */ 1164 public int filterCountByG_V(long groupId, long vocabularyId); 1165 1166 /** 1167 * Returns the number of asset categories that the user has permission to view where groupId = ? and vocabularyId = any ?. 1168 * 1169 * @param groupId the group ID 1170 * @param vocabularyIds the vocabulary IDs 1171 * @return the number of matching asset categories that the user has permission to view 1172 */ 1173 public int filterCountByG_V(long groupId, long[] vocabularyIds); 1174 1175 /** 1176 * Returns all the asset categories where parentCategoryId = ? and name = ?. 1177 * 1178 * @param parentCategoryId the parent category ID 1179 * @param name the name 1180 * @return the matching asset categories 1181 */ 1182 public java.util.List<AssetCategory> findByP_N(long parentCategoryId, 1183 java.lang.String name); 1184 1185 /** 1186 * Returns a range of all the asset categories where parentCategoryId = ? and name = ?. 1187 * 1188 * <p> 1189 * 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 AssetCategoryModelImpl}. 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. 1190 * </p> 1191 * 1192 * @param parentCategoryId the parent category ID 1193 * @param name the name 1194 * @param start the lower bound of the range of asset categories 1195 * @param end the upper bound of the range of asset categories (not inclusive) 1196 * @return the range of matching asset categories 1197 */ 1198 public java.util.List<AssetCategory> findByP_N(long parentCategoryId, 1199 java.lang.String name, int start, int end); 1200 1201 /** 1202 * Returns an ordered range of all the asset categories where parentCategoryId = ? and name = ?. 1203 * 1204 * <p> 1205 * 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 AssetCategoryModelImpl}. 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. 1206 * </p> 1207 * 1208 * @param parentCategoryId the parent category ID 1209 * @param name the name 1210 * @param start the lower bound of the range of asset categories 1211 * @param end the upper bound of the range of asset categories (not inclusive) 1212 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1213 * @return the ordered range of matching asset categories 1214 */ 1215 public java.util.List<AssetCategory> findByP_N(long parentCategoryId, 1216 java.lang.String name, int start, int end, 1217 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1218 1219 /** 1220 * Returns an ordered range of all the asset categories where parentCategoryId = ? and name = ?. 1221 * 1222 * <p> 1223 * 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 AssetCategoryModelImpl}. 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. 1224 * </p> 1225 * 1226 * @param parentCategoryId the parent category ID 1227 * @param name the name 1228 * @param start the lower bound of the range of asset categories 1229 * @param end the upper bound of the range of asset categories (not inclusive) 1230 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1231 * @param retrieveFromCache whether to retrieve from the finder cache 1232 * @return the ordered range of matching asset categories 1233 */ 1234 public java.util.List<AssetCategory> findByP_N(long parentCategoryId, 1235 java.lang.String name, int start, int end, 1236 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator, 1237 boolean retrieveFromCache); 1238 1239 /** 1240 * Returns the first asset category in the ordered set where parentCategoryId = ? and name = ?. 1241 * 1242 * @param parentCategoryId the parent category ID 1243 * @param name the name 1244 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1245 * @return the first matching asset category 1246 * @throws NoSuchCategoryException if a matching asset category could not be found 1247 */ 1248 public AssetCategory findByP_N_First(long parentCategoryId, 1249 java.lang.String name, 1250 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 1251 throws NoSuchCategoryException; 1252 1253 /** 1254 * Returns the first asset category in the ordered set where parentCategoryId = ? and name = ?. 1255 * 1256 * @param parentCategoryId the parent category ID 1257 * @param name the name 1258 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1259 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 1260 */ 1261 public AssetCategory fetchByP_N_First(long parentCategoryId, 1262 java.lang.String name, 1263 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1264 1265 /** 1266 * Returns the last asset category in the ordered set where parentCategoryId = ? and name = ?. 1267 * 1268 * @param parentCategoryId the parent category ID 1269 * @param name the name 1270 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1271 * @return the last matching asset category 1272 * @throws NoSuchCategoryException if a matching asset category could not be found 1273 */ 1274 public AssetCategory findByP_N_Last(long parentCategoryId, 1275 java.lang.String name, 1276 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 1277 throws NoSuchCategoryException; 1278 1279 /** 1280 * Returns the last asset category in the ordered set where parentCategoryId = ? and name = ?. 1281 * 1282 * @param parentCategoryId the parent category ID 1283 * @param name the name 1284 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1285 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 1286 */ 1287 public AssetCategory fetchByP_N_Last(long parentCategoryId, 1288 java.lang.String name, 1289 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1290 1291 /** 1292 * Returns the asset categories before and after the current asset category in the ordered set where parentCategoryId = ? and name = ?. 1293 * 1294 * @param categoryId the primary key of the current asset category 1295 * @param parentCategoryId the parent category ID 1296 * @param name the name 1297 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1298 * @return the previous, current, and next asset category 1299 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 1300 */ 1301 public AssetCategory[] findByP_N_PrevAndNext(long categoryId, 1302 long parentCategoryId, java.lang.String name, 1303 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 1304 throws NoSuchCategoryException; 1305 1306 /** 1307 * Removes all the asset categories where parentCategoryId = ? and name = ? from the database. 1308 * 1309 * @param parentCategoryId the parent category ID 1310 * @param name the name 1311 */ 1312 public void removeByP_N(long parentCategoryId, java.lang.String name); 1313 1314 /** 1315 * Returns the number of asset categories where parentCategoryId = ? and name = ?. 1316 * 1317 * @param parentCategoryId the parent category ID 1318 * @param name the name 1319 * @return the number of matching asset categories 1320 */ 1321 public int countByP_N(long parentCategoryId, java.lang.String name); 1322 1323 /** 1324 * Returns all the asset categories where parentCategoryId = ? and vocabularyId = ?. 1325 * 1326 * @param parentCategoryId the parent category ID 1327 * @param vocabularyId the vocabulary ID 1328 * @return the matching asset categories 1329 */ 1330 public java.util.List<AssetCategory> findByP_V(long parentCategoryId, 1331 long vocabularyId); 1332 1333 /** 1334 * Returns a range of all the asset categories where parentCategoryId = ? and vocabularyId = ?. 1335 * 1336 * <p> 1337 * 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 AssetCategoryModelImpl}. 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. 1338 * </p> 1339 * 1340 * @param parentCategoryId the parent category ID 1341 * @param vocabularyId the vocabulary ID 1342 * @param start the lower bound of the range of asset categories 1343 * @param end the upper bound of the range of asset categories (not inclusive) 1344 * @return the range of matching asset categories 1345 */ 1346 public java.util.List<AssetCategory> findByP_V(long parentCategoryId, 1347 long vocabularyId, int start, int end); 1348 1349 /** 1350 * Returns an ordered range of all the asset categories where parentCategoryId = ? and vocabularyId = ?. 1351 * 1352 * <p> 1353 * 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 AssetCategoryModelImpl}. 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. 1354 * </p> 1355 * 1356 * @param parentCategoryId the parent category ID 1357 * @param vocabularyId the vocabulary ID 1358 * @param start the lower bound of the range of asset categories 1359 * @param end the upper bound of the range of asset categories (not inclusive) 1360 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1361 * @return the ordered range of matching asset categories 1362 */ 1363 public java.util.List<AssetCategory> findByP_V(long parentCategoryId, 1364 long vocabularyId, int start, int end, 1365 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1366 1367 /** 1368 * Returns an ordered range of all the asset categories where parentCategoryId = ? and vocabularyId = ?. 1369 * 1370 * <p> 1371 * 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 AssetCategoryModelImpl}. 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. 1372 * </p> 1373 * 1374 * @param parentCategoryId the parent category ID 1375 * @param vocabularyId the vocabulary ID 1376 * @param start the lower bound of the range of asset categories 1377 * @param end the upper bound of the range of asset categories (not inclusive) 1378 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1379 * @param retrieveFromCache whether to retrieve from the finder cache 1380 * @return the ordered range of matching asset categories 1381 */ 1382 public java.util.List<AssetCategory> findByP_V(long parentCategoryId, 1383 long vocabularyId, int start, int end, 1384 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator, 1385 boolean retrieveFromCache); 1386 1387 /** 1388 * Returns the first asset category in the ordered set where parentCategoryId = ? and vocabularyId = ?. 1389 * 1390 * @param parentCategoryId the parent category ID 1391 * @param vocabularyId the vocabulary ID 1392 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1393 * @return the first matching asset category 1394 * @throws NoSuchCategoryException if a matching asset category could not be found 1395 */ 1396 public AssetCategory findByP_V_First(long parentCategoryId, 1397 long vocabularyId, 1398 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 1399 throws NoSuchCategoryException; 1400 1401 /** 1402 * Returns the first asset category in the ordered set where parentCategoryId = ? and vocabularyId = ?. 1403 * 1404 * @param parentCategoryId the parent category ID 1405 * @param vocabularyId the vocabulary ID 1406 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1407 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 1408 */ 1409 public AssetCategory fetchByP_V_First(long parentCategoryId, 1410 long vocabularyId, 1411 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1412 1413 /** 1414 * Returns the last asset category in the ordered set where parentCategoryId = ? and vocabularyId = ?. 1415 * 1416 * @param parentCategoryId the parent category ID 1417 * @param vocabularyId the vocabulary ID 1418 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1419 * @return the last matching asset category 1420 * @throws NoSuchCategoryException if a matching asset category could not be found 1421 */ 1422 public AssetCategory findByP_V_Last(long parentCategoryId, 1423 long vocabularyId, 1424 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 1425 throws NoSuchCategoryException; 1426 1427 /** 1428 * Returns the last asset category in the ordered set where parentCategoryId = ? and vocabularyId = ?. 1429 * 1430 * @param parentCategoryId the parent category ID 1431 * @param vocabularyId the vocabulary ID 1432 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1433 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 1434 */ 1435 public AssetCategory fetchByP_V_Last(long parentCategoryId, 1436 long vocabularyId, 1437 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1438 1439 /** 1440 * Returns the asset categories before and after the current asset category in the ordered set where parentCategoryId = ? and vocabularyId = ?. 1441 * 1442 * @param categoryId the primary key of the current asset category 1443 * @param parentCategoryId the parent category ID 1444 * @param vocabularyId the vocabulary ID 1445 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1446 * @return the previous, current, and next asset category 1447 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 1448 */ 1449 public AssetCategory[] findByP_V_PrevAndNext(long categoryId, 1450 long parentCategoryId, long vocabularyId, 1451 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 1452 throws NoSuchCategoryException; 1453 1454 /** 1455 * Removes all the asset categories where parentCategoryId = ? and vocabularyId = ? from the database. 1456 * 1457 * @param parentCategoryId the parent category ID 1458 * @param vocabularyId the vocabulary ID 1459 */ 1460 public void removeByP_V(long parentCategoryId, long vocabularyId); 1461 1462 /** 1463 * Returns the number of asset categories where parentCategoryId = ? and vocabularyId = ?. 1464 * 1465 * @param parentCategoryId the parent category ID 1466 * @param vocabularyId the vocabulary ID 1467 * @return the number of matching asset categories 1468 */ 1469 public int countByP_V(long parentCategoryId, long vocabularyId); 1470 1471 /** 1472 * Returns all the asset categories where name = ? and vocabularyId = ?. 1473 * 1474 * @param name the name 1475 * @param vocabularyId the vocabulary ID 1476 * @return the matching asset categories 1477 */ 1478 public java.util.List<AssetCategory> findByN_V(java.lang.String name, 1479 long vocabularyId); 1480 1481 /** 1482 * Returns a range of all the asset categories where name = ? and vocabularyId = ?. 1483 * 1484 * <p> 1485 * 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 AssetCategoryModelImpl}. 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. 1486 * </p> 1487 * 1488 * @param name the name 1489 * @param vocabularyId the vocabulary ID 1490 * @param start the lower bound of the range of asset categories 1491 * @param end the upper bound of the range of asset categories (not inclusive) 1492 * @return the range of matching asset categories 1493 */ 1494 public java.util.List<AssetCategory> findByN_V(java.lang.String name, 1495 long vocabularyId, int start, int end); 1496 1497 /** 1498 * Returns an ordered range of all the asset categories where name = ? and vocabularyId = ?. 1499 * 1500 * <p> 1501 * 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 AssetCategoryModelImpl}. 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. 1502 * </p> 1503 * 1504 * @param name the name 1505 * @param vocabularyId the vocabulary ID 1506 * @param start the lower bound of the range of asset categories 1507 * @param end the upper bound of the range of asset categories (not inclusive) 1508 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1509 * @return the ordered range of matching asset categories 1510 */ 1511 public java.util.List<AssetCategory> findByN_V(java.lang.String name, 1512 long vocabularyId, int start, int end, 1513 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1514 1515 /** 1516 * Returns an ordered range of all the asset categories where name = ? and vocabularyId = ?. 1517 * 1518 * <p> 1519 * 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 AssetCategoryModelImpl}. 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. 1520 * </p> 1521 * 1522 * @param name the name 1523 * @param vocabularyId the vocabulary ID 1524 * @param start the lower bound of the range of asset categories 1525 * @param end the upper bound of the range of asset categories (not inclusive) 1526 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1527 * @param retrieveFromCache whether to retrieve from the finder cache 1528 * @return the ordered range of matching asset categories 1529 */ 1530 public java.util.List<AssetCategory> findByN_V(java.lang.String name, 1531 long vocabularyId, int start, int end, 1532 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator, 1533 boolean retrieveFromCache); 1534 1535 /** 1536 * Returns the first asset category in the ordered set where name = ? and vocabularyId = ?. 1537 * 1538 * @param name the name 1539 * @param vocabularyId the vocabulary ID 1540 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1541 * @return the first matching asset category 1542 * @throws NoSuchCategoryException if a matching asset category could not be found 1543 */ 1544 public AssetCategory findByN_V_First(java.lang.String name, 1545 long vocabularyId, 1546 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 1547 throws NoSuchCategoryException; 1548 1549 /** 1550 * Returns the first asset category in the ordered set where name = ? and vocabularyId = ?. 1551 * 1552 * @param name the name 1553 * @param vocabularyId the vocabulary ID 1554 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1555 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 1556 */ 1557 public AssetCategory fetchByN_V_First(java.lang.String name, 1558 long vocabularyId, 1559 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1560 1561 /** 1562 * Returns the last asset category in the ordered set where name = ? and vocabularyId = ?. 1563 * 1564 * @param name the name 1565 * @param vocabularyId the vocabulary ID 1566 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1567 * @return the last matching asset category 1568 * @throws NoSuchCategoryException if a matching asset category could not be found 1569 */ 1570 public AssetCategory findByN_V_Last(java.lang.String name, 1571 long vocabularyId, 1572 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 1573 throws NoSuchCategoryException; 1574 1575 /** 1576 * Returns the last asset category in the ordered set where name = ? and vocabularyId = ?. 1577 * 1578 * @param name the name 1579 * @param vocabularyId the vocabulary ID 1580 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1581 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 1582 */ 1583 public AssetCategory fetchByN_V_Last(java.lang.String name, 1584 long vocabularyId, 1585 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1586 1587 /** 1588 * Returns the asset categories before and after the current asset category in the ordered set where name = ? and vocabularyId = ?. 1589 * 1590 * @param categoryId the primary key of the current asset category 1591 * @param name the name 1592 * @param vocabularyId the vocabulary ID 1593 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1594 * @return the previous, current, and next asset category 1595 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 1596 */ 1597 public AssetCategory[] findByN_V_PrevAndNext(long categoryId, 1598 java.lang.String name, long vocabularyId, 1599 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 1600 throws NoSuchCategoryException; 1601 1602 /** 1603 * Removes all the asset categories where name = ? and vocabularyId = ? from the database. 1604 * 1605 * @param name the name 1606 * @param vocabularyId the vocabulary ID 1607 */ 1608 public void removeByN_V(java.lang.String name, long vocabularyId); 1609 1610 /** 1611 * Returns the number of asset categories where name = ? and vocabularyId = ?. 1612 * 1613 * @param name the name 1614 * @param vocabularyId the vocabulary ID 1615 * @return the number of matching asset categories 1616 */ 1617 public int countByN_V(java.lang.String name, long vocabularyId); 1618 1619 /** 1620 * Returns all the asset categories where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 1621 * 1622 * @param groupId the group ID 1623 * @param parentCategoryId the parent category ID 1624 * @param vocabularyId the vocabulary ID 1625 * @return the matching asset categories 1626 */ 1627 public java.util.List<AssetCategory> findByG_P_V(long groupId, 1628 long parentCategoryId, long vocabularyId); 1629 1630 /** 1631 * Returns a range of all the asset categories where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 1632 * 1633 * <p> 1634 * 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 AssetCategoryModelImpl}. 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. 1635 * </p> 1636 * 1637 * @param groupId the group ID 1638 * @param parentCategoryId the parent category ID 1639 * @param vocabularyId the vocabulary ID 1640 * @param start the lower bound of the range of asset categories 1641 * @param end the upper bound of the range of asset categories (not inclusive) 1642 * @return the range of matching asset categories 1643 */ 1644 public java.util.List<AssetCategory> findByG_P_V(long groupId, 1645 long parentCategoryId, long vocabularyId, int start, int end); 1646 1647 /** 1648 * Returns an ordered range of all the asset categories where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 1649 * 1650 * <p> 1651 * 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 AssetCategoryModelImpl}. 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. 1652 * </p> 1653 * 1654 * @param groupId the group ID 1655 * @param parentCategoryId the parent category ID 1656 * @param vocabularyId the vocabulary ID 1657 * @param start the lower bound of the range of asset categories 1658 * @param end the upper bound of the range of asset categories (not inclusive) 1659 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1660 * @return the ordered range of matching asset categories 1661 */ 1662 public java.util.List<AssetCategory> findByG_P_V(long groupId, 1663 long parentCategoryId, long vocabularyId, int start, int end, 1664 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1665 1666 /** 1667 * Returns an ordered range of all the asset categories where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 1668 * 1669 * <p> 1670 * 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 AssetCategoryModelImpl}. 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. 1671 * </p> 1672 * 1673 * @param groupId the group ID 1674 * @param parentCategoryId the parent category ID 1675 * @param vocabularyId the vocabulary ID 1676 * @param start the lower bound of the range of asset categories 1677 * @param end the upper bound of the range of asset categories (not inclusive) 1678 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1679 * @param retrieveFromCache whether to retrieve from the finder cache 1680 * @return the ordered range of matching asset categories 1681 */ 1682 public java.util.List<AssetCategory> findByG_P_V(long groupId, 1683 long parentCategoryId, long vocabularyId, int start, int end, 1684 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator, 1685 boolean retrieveFromCache); 1686 1687 /** 1688 * Returns the first asset category in the ordered set where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 1689 * 1690 * @param groupId the group ID 1691 * @param parentCategoryId the parent category ID 1692 * @param vocabularyId the vocabulary ID 1693 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1694 * @return the first matching asset category 1695 * @throws NoSuchCategoryException if a matching asset category could not be found 1696 */ 1697 public AssetCategory findByG_P_V_First(long groupId, long parentCategoryId, 1698 long vocabularyId, 1699 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 1700 throws NoSuchCategoryException; 1701 1702 /** 1703 * Returns the first asset category in the ordered set where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 1704 * 1705 * @param groupId the group ID 1706 * @param parentCategoryId the parent category ID 1707 * @param vocabularyId the vocabulary ID 1708 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1709 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 1710 */ 1711 public AssetCategory fetchByG_P_V_First(long groupId, 1712 long parentCategoryId, long vocabularyId, 1713 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1714 1715 /** 1716 * Returns the last asset category in the ordered set where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 1717 * 1718 * @param groupId the group ID 1719 * @param parentCategoryId the parent category ID 1720 * @param vocabularyId the vocabulary ID 1721 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1722 * @return the last matching asset category 1723 * @throws NoSuchCategoryException if a matching asset category could not be found 1724 */ 1725 public AssetCategory findByG_P_V_Last(long groupId, long parentCategoryId, 1726 long vocabularyId, 1727 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 1728 throws NoSuchCategoryException; 1729 1730 /** 1731 * Returns the last asset category in the ordered set where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 1732 * 1733 * @param groupId the group ID 1734 * @param parentCategoryId the parent category ID 1735 * @param vocabularyId the vocabulary ID 1736 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1737 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 1738 */ 1739 public AssetCategory fetchByG_P_V_Last(long groupId, long parentCategoryId, 1740 long vocabularyId, 1741 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1742 1743 /** 1744 * Returns the asset categories before and after the current asset category in the ordered set where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 1745 * 1746 * @param categoryId the primary key of the current asset category 1747 * @param groupId the group ID 1748 * @param parentCategoryId the parent category ID 1749 * @param vocabularyId the vocabulary ID 1750 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1751 * @return the previous, current, and next asset category 1752 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 1753 */ 1754 public AssetCategory[] findByG_P_V_PrevAndNext(long categoryId, 1755 long groupId, long parentCategoryId, long vocabularyId, 1756 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 1757 throws NoSuchCategoryException; 1758 1759 /** 1760 * Returns all the asset categories that the user has permission to view where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 1761 * 1762 * @param groupId the group ID 1763 * @param parentCategoryId the parent category ID 1764 * @param vocabularyId the vocabulary ID 1765 * @return the matching asset categories that the user has permission to view 1766 */ 1767 public java.util.List<AssetCategory> filterFindByG_P_V(long groupId, 1768 long parentCategoryId, long vocabularyId); 1769 1770 /** 1771 * Returns a range of all the asset categories that the user has permission to view where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 1772 * 1773 * <p> 1774 * 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 AssetCategoryModelImpl}. 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. 1775 * </p> 1776 * 1777 * @param groupId the group ID 1778 * @param parentCategoryId the parent category ID 1779 * @param vocabularyId the vocabulary ID 1780 * @param start the lower bound of the range of asset categories 1781 * @param end the upper bound of the range of asset categories (not inclusive) 1782 * @return the range of matching asset categories that the user has permission to view 1783 */ 1784 public java.util.List<AssetCategory> filterFindByG_P_V(long groupId, 1785 long parentCategoryId, long vocabularyId, int start, int end); 1786 1787 /** 1788 * Returns an ordered range of all the asset categories that the user has permissions to view where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 1789 * 1790 * <p> 1791 * 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 AssetCategoryModelImpl}. 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. 1792 * </p> 1793 * 1794 * @param groupId the group ID 1795 * @param parentCategoryId the parent category ID 1796 * @param vocabularyId the vocabulary ID 1797 * @param start the lower bound of the range of asset categories 1798 * @param end the upper bound of the range of asset categories (not inclusive) 1799 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1800 * @return the ordered range of matching asset categories that the user has permission to view 1801 */ 1802 public java.util.List<AssetCategory> filterFindByG_P_V(long groupId, 1803 long parentCategoryId, long vocabularyId, int start, int end, 1804 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1805 1806 /** 1807 * Returns the asset categories before and after the current asset category in the ordered set of asset categories that the user has permission to view where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 1808 * 1809 * @param categoryId the primary key of the current asset category 1810 * @param groupId the group ID 1811 * @param parentCategoryId the parent category ID 1812 * @param vocabularyId the vocabulary ID 1813 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1814 * @return the previous, current, and next asset category 1815 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 1816 */ 1817 public AssetCategory[] filterFindByG_P_V_PrevAndNext(long categoryId, 1818 long groupId, long parentCategoryId, long vocabularyId, 1819 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 1820 throws NoSuchCategoryException; 1821 1822 /** 1823 * Removes all the asset categories where groupId = ? and parentCategoryId = ? and vocabularyId = ? from the database. 1824 * 1825 * @param groupId the group ID 1826 * @param parentCategoryId the parent category ID 1827 * @param vocabularyId the vocabulary ID 1828 */ 1829 public void removeByG_P_V(long groupId, long parentCategoryId, 1830 long vocabularyId); 1831 1832 /** 1833 * Returns the number of asset categories where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 1834 * 1835 * @param groupId the group ID 1836 * @param parentCategoryId the parent category ID 1837 * @param vocabularyId the vocabulary ID 1838 * @return the number of matching asset categories 1839 */ 1840 public int countByG_P_V(long groupId, long parentCategoryId, 1841 long vocabularyId); 1842 1843 /** 1844 * Returns the number of asset categories that the user has permission to view where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 1845 * 1846 * @param groupId the group ID 1847 * @param parentCategoryId the parent category ID 1848 * @param vocabularyId the vocabulary ID 1849 * @return the number of matching asset categories that the user has permission to view 1850 */ 1851 public int filterCountByG_P_V(long groupId, long parentCategoryId, 1852 long vocabularyId); 1853 1854 /** 1855 * Returns all the asset categories where groupId = ? and name LIKE ? and vocabularyId = ?. 1856 * 1857 * @param groupId the group ID 1858 * @param name the name 1859 * @param vocabularyId the vocabulary ID 1860 * @return the matching asset categories 1861 */ 1862 public java.util.List<AssetCategory> findByG_LikeN_V(long groupId, 1863 java.lang.String name, long vocabularyId); 1864 1865 /** 1866 * Returns a range of all the asset categories where groupId = ? and name LIKE ? and vocabularyId = ?. 1867 * 1868 * <p> 1869 * 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 AssetCategoryModelImpl}. 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. 1870 * </p> 1871 * 1872 * @param groupId the group ID 1873 * @param name the name 1874 * @param vocabularyId the vocabulary ID 1875 * @param start the lower bound of the range of asset categories 1876 * @param end the upper bound of the range of asset categories (not inclusive) 1877 * @return the range of matching asset categories 1878 */ 1879 public java.util.List<AssetCategory> findByG_LikeN_V(long groupId, 1880 java.lang.String name, long vocabularyId, int start, int end); 1881 1882 /** 1883 * Returns an ordered range of all the asset categories where groupId = ? and name LIKE ? and vocabularyId = ?. 1884 * 1885 * <p> 1886 * 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 AssetCategoryModelImpl}. 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. 1887 * </p> 1888 * 1889 * @param groupId the group ID 1890 * @param name the name 1891 * @param vocabularyId the vocabulary ID 1892 * @param start the lower bound of the range of asset categories 1893 * @param end the upper bound of the range of asset categories (not inclusive) 1894 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1895 * @return the ordered range of matching asset categories 1896 */ 1897 public java.util.List<AssetCategory> findByG_LikeN_V(long groupId, 1898 java.lang.String name, long vocabularyId, int start, int end, 1899 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1900 1901 /** 1902 * Returns an ordered range of all the asset categories where groupId = ? and name LIKE ? and vocabularyId = ?. 1903 * 1904 * <p> 1905 * 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 AssetCategoryModelImpl}. 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. 1906 * </p> 1907 * 1908 * @param groupId the group ID 1909 * @param name the name 1910 * @param vocabularyId the vocabulary ID 1911 * @param start the lower bound of the range of asset categories 1912 * @param end the upper bound of the range of asset categories (not inclusive) 1913 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1914 * @param retrieveFromCache whether to retrieve from the finder cache 1915 * @return the ordered range of matching asset categories 1916 */ 1917 public java.util.List<AssetCategory> findByG_LikeN_V(long groupId, 1918 java.lang.String name, long vocabularyId, int start, int end, 1919 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator, 1920 boolean retrieveFromCache); 1921 1922 /** 1923 * Returns the first asset category in the ordered set where groupId = ? and name LIKE ? and vocabularyId = ?. 1924 * 1925 * @param groupId the group ID 1926 * @param name the name 1927 * @param vocabularyId the vocabulary ID 1928 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1929 * @return the first matching asset category 1930 * @throws NoSuchCategoryException if a matching asset category could not be found 1931 */ 1932 public AssetCategory findByG_LikeN_V_First(long groupId, 1933 java.lang.String name, long vocabularyId, 1934 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 1935 throws NoSuchCategoryException; 1936 1937 /** 1938 * Returns the first asset category in the ordered set where groupId = ? and name LIKE ? and vocabularyId = ?. 1939 * 1940 * @param groupId the group ID 1941 * @param name the name 1942 * @param vocabularyId the vocabulary ID 1943 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1944 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 1945 */ 1946 public AssetCategory fetchByG_LikeN_V_First(long groupId, 1947 java.lang.String name, long vocabularyId, 1948 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1949 1950 /** 1951 * Returns the last asset category in the ordered set where groupId = ? and name LIKE ? and vocabularyId = ?. 1952 * 1953 * @param groupId the group ID 1954 * @param name the name 1955 * @param vocabularyId the vocabulary ID 1956 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1957 * @return the last matching asset category 1958 * @throws NoSuchCategoryException if a matching asset category could not be found 1959 */ 1960 public AssetCategory findByG_LikeN_V_Last(long groupId, 1961 java.lang.String name, long vocabularyId, 1962 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 1963 throws NoSuchCategoryException; 1964 1965 /** 1966 * Returns the last asset category in the ordered set where groupId = ? and name LIKE ? and vocabularyId = ?. 1967 * 1968 * @param groupId the group ID 1969 * @param name the name 1970 * @param vocabularyId the vocabulary ID 1971 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1972 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 1973 */ 1974 public AssetCategory fetchByG_LikeN_V_Last(long groupId, 1975 java.lang.String name, long vocabularyId, 1976 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1977 1978 /** 1979 * Returns the asset categories before and after the current asset category in the ordered set where groupId = ? and name LIKE ? and vocabularyId = ?. 1980 * 1981 * @param categoryId the primary key of the current asset category 1982 * @param groupId the group ID 1983 * @param name the name 1984 * @param vocabularyId the vocabulary ID 1985 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1986 * @return the previous, current, and next asset category 1987 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 1988 */ 1989 public AssetCategory[] findByG_LikeN_V_PrevAndNext(long categoryId, 1990 long groupId, java.lang.String name, long vocabularyId, 1991 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 1992 throws NoSuchCategoryException; 1993 1994 /** 1995 * Returns all the asset categories that the user has permission to view where groupId = ? and name LIKE ? and vocabularyId = ?. 1996 * 1997 * @param groupId the group ID 1998 * @param name the name 1999 * @param vocabularyId the vocabulary ID 2000 * @return the matching asset categories that the user has permission to view 2001 */ 2002 public java.util.List<AssetCategory> filterFindByG_LikeN_V(long groupId, 2003 java.lang.String name, long vocabularyId); 2004 2005 /** 2006 * Returns a range of all the asset categories that the user has permission to view where groupId = ? and name LIKE ? and vocabularyId = ?. 2007 * 2008 * <p> 2009 * 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 AssetCategoryModelImpl}. 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. 2010 * </p> 2011 * 2012 * @param groupId the group ID 2013 * @param name the name 2014 * @param vocabularyId the vocabulary ID 2015 * @param start the lower bound of the range of asset categories 2016 * @param end the upper bound of the range of asset categories (not inclusive) 2017 * @return the range of matching asset categories that the user has permission to view 2018 */ 2019 public java.util.List<AssetCategory> filterFindByG_LikeN_V(long groupId, 2020 java.lang.String name, long vocabularyId, int start, int end); 2021 2022 /** 2023 * Returns an ordered range of all the asset categories that the user has permissions to view where groupId = ? and name LIKE ? and vocabularyId = ?. 2024 * 2025 * <p> 2026 * 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 AssetCategoryModelImpl}. 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. 2027 * </p> 2028 * 2029 * @param groupId the group ID 2030 * @param name the name 2031 * @param vocabularyId the vocabulary ID 2032 * @param start the lower bound of the range of asset categories 2033 * @param end the upper bound of the range of asset categories (not inclusive) 2034 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2035 * @return the ordered range of matching asset categories that the user has permission to view 2036 */ 2037 public java.util.List<AssetCategory> filterFindByG_LikeN_V(long groupId, 2038 java.lang.String name, long vocabularyId, int start, int end, 2039 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 2040 2041 /** 2042 * Returns the asset categories before and after the current asset category in the ordered set of asset categories that the user has permission to view where groupId = ? and name LIKE ? and vocabularyId = ?. 2043 * 2044 * @param categoryId the primary key of the current asset category 2045 * @param groupId the group ID 2046 * @param name the name 2047 * @param vocabularyId the vocabulary ID 2048 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2049 * @return the previous, current, and next asset category 2050 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 2051 */ 2052 public AssetCategory[] filterFindByG_LikeN_V_PrevAndNext(long categoryId, 2053 long groupId, java.lang.String name, long vocabularyId, 2054 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 2055 throws NoSuchCategoryException; 2056 2057 /** 2058 * Returns all the asset categories that the user has permission to view where groupId = ? and name LIKE ? and vocabularyId = any ?. 2059 * 2060 * @param groupId the group ID 2061 * @param name the name 2062 * @param vocabularyIds the vocabulary IDs 2063 * @return the matching asset categories that the user has permission to view 2064 */ 2065 public java.util.List<AssetCategory> filterFindByG_LikeN_V(long groupId, 2066 java.lang.String name, long[] vocabularyIds); 2067 2068 /** 2069 * Returns a range of all the asset categories that the user has permission to view where groupId = ? and name LIKE ? and vocabularyId = any ?. 2070 * 2071 * <p> 2072 * 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 AssetCategoryModelImpl}. 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. 2073 * </p> 2074 * 2075 * @param groupId the group ID 2076 * @param name the name 2077 * @param vocabularyIds the vocabulary IDs 2078 * @param start the lower bound of the range of asset categories 2079 * @param end the upper bound of the range of asset categories (not inclusive) 2080 * @return the range of matching asset categories that the user has permission to view 2081 */ 2082 public java.util.List<AssetCategory> filterFindByG_LikeN_V(long groupId, 2083 java.lang.String name, long[] vocabularyIds, int start, int end); 2084 2085 /** 2086 * Returns an ordered range of all the asset categories that the user has permission to view where groupId = ? and name LIKE ? and vocabularyId = any ?. 2087 * 2088 * <p> 2089 * 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 AssetCategoryModelImpl}. 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. 2090 * </p> 2091 * 2092 * @param groupId the group ID 2093 * @param name the name 2094 * @param vocabularyIds the vocabulary IDs 2095 * @param start the lower bound of the range of asset categories 2096 * @param end the upper bound of the range of asset categories (not inclusive) 2097 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2098 * @return the ordered range of matching asset categories that the user has permission to view 2099 */ 2100 public java.util.List<AssetCategory> filterFindByG_LikeN_V(long groupId, 2101 java.lang.String name, long[] vocabularyIds, int start, int end, 2102 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 2103 2104 /** 2105 * Returns all the asset categories where groupId = ? and name LIKE ? and vocabularyId = any ?. 2106 * 2107 * <p> 2108 * 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 AssetCategoryModelImpl}. 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. 2109 * </p> 2110 * 2111 * @param groupId the group ID 2112 * @param name the name 2113 * @param vocabularyIds the vocabulary IDs 2114 * @return the matching asset categories 2115 */ 2116 public java.util.List<AssetCategory> findByG_LikeN_V(long groupId, 2117 java.lang.String name, long[] vocabularyIds); 2118 2119 /** 2120 * Returns a range of all the asset categories where groupId = ? and name LIKE ? and vocabularyId = any ?. 2121 * 2122 * <p> 2123 * 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 AssetCategoryModelImpl}. 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. 2124 * </p> 2125 * 2126 * @param groupId the group ID 2127 * @param name the name 2128 * @param vocabularyIds the vocabulary IDs 2129 * @param start the lower bound of the range of asset categories 2130 * @param end the upper bound of the range of asset categories (not inclusive) 2131 * @return the range of matching asset categories 2132 */ 2133 public java.util.List<AssetCategory> findByG_LikeN_V(long groupId, 2134 java.lang.String name, long[] vocabularyIds, int start, int end); 2135 2136 /** 2137 * Returns an ordered range of all the asset categories where groupId = ? and name LIKE ? and vocabularyId = any ?. 2138 * 2139 * <p> 2140 * 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 AssetCategoryModelImpl}. 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. 2141 * </p> 2142 * 2143 * @param groupId the group ID 2144 * @param name the name 2145 * @param vocabularyIds the vocabulary IDs 2146 * @param start the lower bound of the range of asset categories 2147 * @param end the upper bound of the range of asset categories (not inclusive) 2148 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2149 * @return the ordered range of matching asset categories 2150 */ 2151 public java.util.List<AssetCategory> findByG_LikeN_V(long groupId, 2152 java.lang.String name, long[] vocabularyIds, int start, int end, 2153 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 2154 2155 /** 2156 * Returns an ordered range of all the asset categories where groupId = ? and name LIKE ? and vocabularyId = ?, optionally using the finder cache. 2157 * 2158 * <p> 2159 * 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 AssetCategoryModelImpl}. 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. 2160 * </p> 2161 * 2162 * @param groupId the group ID 2163 * @param name the name 2164 * @param vocabularyId the vocabulary ID 2165 * @param start the lower bound of the range of asset categories 2166 * @param end the upper bound of the range of asset categories (not inclusive) 2167 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2168 * @param retrieveFromCache whether to retrieve from the finder cache 2169 * @return the ordered range of matching asset categories 2170 */ 2171 public java.util.List<AssetCategory> findByG_LikeN_V(long groupId, 2172 java.lang.String name, long[] vocabularyIds, int start, int end, 2173 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator, 2174 boolean retrieveFromCache); 2175 2176 /** 2177 * Removes all the asset categories where groupId = ? and name LIKE ? and vocabularyId = ? from the database. 2178 * 2179 * @param groupId the group ID 2180 * @param name the name 2181 * @param vocabularyId the vocabulary ID 2182 */ 2183 public void removeByG_LikeN_V(long groupId, java.lang.String name, 2184 long vocabularyId); 2185 2186 /** 2187 * Returns the number of asset categories where groupId = ? and name LIKE ? and vocabularyId = ?. 2188 * 2189 * @param groupId the group ID 2190 * @param name the name 2191 * @param vocabularyId the vocabulary ID 2192 * @return the number of matching asset categories 2193 */ 2194 public int countByG_LikeN_V(long groupId, java.lang.String name, 2195 long vocabularyId); 2196 2197 /** 2198 * Returns the number of asset categories where groupId = ? and name LIKE ? and vocabularyId = any ?. 2199 * 2200 * @param groupId the group ID 2201 * @param name the name 2202 * @param vocabularyIds the vocabulary IDs 2203 * @return the number of matching asset categories 2204 */ 2205 public int countByG_LikeN_V(long groupId, java.lang.String name, 2206 long[] vocabularyIds); 2207 2208 /** 2209 * Returns the number of asset categories that the user has permission to view where groupId = ? and name LIKE ? and vocabularyId = ?. 2210 * 2211 * @param groupId the group ID 2212 * @param name the name 2213 * @param vocabularyId the vocabulary ID 2214 * @return the number of matching asset categories that the user has permission to view 2215 */ 2216 public int filterCountByG_LikeN_V(long groupId, java.lang.String name, 2217 long vocabularyId); 2218 2219 /** 2220 * Returns the number of asset categories that the user has permission to view where groupId = ? and name LIKE ? and vocabularyId = any ?. 2221 * 2222 * @param groupId the group ID 2223 * @param name the name 2224 * @param vocabularyIds the vocabulary IDs 2225 * @return the number of matching asset categories that the user has permission to view 2226 */ 2227 public int filterCountByG_LikeN_V(long groupId, java.lang.String name, 2228 long[] vocabularyIds); 2229 2230 /** 2231 * Returns the asset category where parentCategoryId = ? and name = ? and vocabularyId = ? or throws a {@link NoSuchCategoryException} if it could not be found. 2232 * 2233 * @param parentCategoryId the parent category ID 2234 * @param name the name 2235 * @param vocabularyId the vocabulary ID 2236 * @return the matching asset category 2237 * @throws NoSuchCategoryException if a matching asset category could not be found 2238 */ 2239 public AssetCategory findByP_N_V(long parentCategoryId, 2240 java.lang.String name, long vocabularyId) 2241 throws NoSuchCategoryException; 2242 2243 /** 2244 * Returns the asset category where parentCategoryId = ? and name = ? and vocabularyId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 2245 * 2246 * @param parentCategoryId the parent category ID 2247 * @param name the name 2248 * @param vocabularyId the vocabulary ID 2249 * @return the matching asset category, or <code>null</code> if a matching asset category could not be found 2250 */ 2251 public AssetCategory fetchByP_N_V(long parentCategoryId, 2252 java.lang.String name, long vocabularyId); 2253 2254 /** 2255 * Returns the asset category where parentCategoryId = ? and name = ? and vocabularyId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 2256 * 2257 * @param parentCategoryId the parent category ID 2258 * @param name the name 2259 * @param vocabularyId the vocabulary ID 2260 * @param retrieveFromCache whether to retrieve from the finder cache 2261 * @return the matching asset category, or <code>null</code> if a matching asset category could not be found 2262 */ 2263 public AssetCategory fetchByP_N_V(long parentCategoryId, 2264 java.lang.String name, long vocabularyId, boolean retrieveFromCache); 2265 2266 /** 2267 * Removes the asset category where parentCategoryId = ? and name = ? and vocabularyId = ? from the database. 2268 * 2269 * @param parentCategoryId the parent category ID 2270 * @param name the name 2271 * @param vocabularyId the vocabulary ID 2272 * @return the asset category that was removed 2273 */ 2274 public AssetCategory removeByP_N_V(long parentCategoryId, 2275 java.lang.String name, long vocabularyId) 2276 throws NoSuchCategoryException; 2277 2278 /** 2279 * Returns the number of asset categories where parentCategoryId = ? and name = ? and vocabularyId = ?. 2280 * 2281 * @param parentCategoryId the parent category ID 2282 * @param name the name 2283 * @param vocabularyId the vocabulary ID 2284 * @return the number of matching asset categories 2285 */ 2286 public int countByP_N_V(long parentCategoryId, java.lang.String name, 2287 long vocabularyId); 2288 2289 /** 2290 * Returns all the asset categories where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2291 * 2292 * @param groupId the group ID 2293 * @param parentCategoryId the parent category ID 2294 * @param name the name 2295 * @param vocabularyId the vocabulary ID 2296 * @return the matching asset categories 2297 */ 2298 public java.util.List<AssetCategory> findByG_P_N_V(long groupId, 2299 long parentCategoryId, java.lang.String name, long vocabularyId); 2300 2301 /** 2302 * Returns a range of all the asset categories where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2303 * 2304 * <p> 2305 * 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 AssetCategoryModelImpl}. 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. 2306 * </p> 2307 * 2308 * @param groupId the group ID 2309 * @param parentCategoryId the parent category ID 2310 * @param name the name 2311 * @param vocabularyId the vocabulary ID 2312 * @param start the lower bound of the range of asset categories 2313 * @param end the upper bound of the range of asset categories (not inclusive) 2314 * @return the range of matching asset categories 2315 */ 2316 public java.util.List<AssetCategory> findByG_P_N_V(long groupId, 2317 long parentCategoryId, java.lang.String name, long vocabularyId, 2318 int start, int end); 2319 2320 /** 2321 * Returns an ordered range of all the asset categories where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2322 * 2323 * <p> 2324 * 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 AssetCategoryModelImpl}. 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. 2325 * </p> 2326 * 2327 * @param groupId the group ID 2328 * @param parentCategoryId the parent category ID 2329 * @param name the name 2330 * @param vocabularyId the vocabulary ID 2331 * @param start the lower bound of the range of asset categories 2332 * @param end the upper bound of the range of asset categories (not inclusive) 2333 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2334 * @return the ordered range of matching asset categories 2335 */ 2336 public java.util.List<AssetCategory> findByG_P_N_V(long groupId, 2337 long parentCategoryId, java.lang.String name, long vocabularyId, 2338 int start, int end, 2339 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 2340 2341 /** 2342 * Returns an ordered range of all the asset categories where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2343 * 2344 * <p> 2345 * 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 AssetCategoryModelImpl}. 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. 2346 * </p> 2347 * 2348 * @param groupId the group ID 2349 * @param parentCategoryId the parent category ID 2350 * @param name the name 2351 * @param vocabularyId the vocabulary ID 2352 * @param start the lower bound of the range of asset categories 2353 * @param end the upper bound of the range of asset categories (not inclusive) 2354 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2355 * @param retrieveFromCache whether to retrieve from the finder cache 2356 * @return the ordered range of matching asset categories 2357 */ 2358 public java.util.List<AssetCategory> findByG_P_N_V(long groupId, 2359 long parentCategoryId, java.lang.String name, long vocabularyId, 2360 int start, int end, 2361 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator, 2362 boolean retrieveFromCache); 2363 2364 /** 2365 * Returns the first asset category in the ordered set where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2366 * 2367 * @param groupId the group ID 2368 * @param parentCategoryId the parent category ID 2369 * @param name the name 2370 * @param vocabularyId the vocabulary ID 2371 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2372 * @return the first matching asset category 2373 * @throws NoSuchCategoryException if a matching asset category could not be found 2374 */ 2375 public AssetCategory findByG_P_N_V_First(long groupId, 2376 long parentCategoryId, java.lang.String name, long vocabularyId, 2377 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 2378 throws NoSuchCategoryException; 2379 2380 /** 2381 * Returns the first asset category in the ordered set where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2382 * 2383 * @param groupId the group ID 2384 * @param parentCategoryId the parent category ID 2385 * @param name the name 2386 * @param vocabularyId the vocabulary ID 2387 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2388 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 2389 */ 2390 public AssetCategory fetchByG_P_N_V_First(long groupId, 2391 long parentCategoryId, java.lang.String name, long vocabularyId, 2392 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 2393 2394 /** 2395 * Returns the last asset category in the ordered set where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2396 * 2397 * @param groupId the group ID 2398 * @param parentCategoryId the parent category ID 2399 * @param name the name 2400 * @param vocabularyId the vocabulary ID 2401 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2402 * @return the last matching asset category 2403 * @throws NoSuchCategoryException if a matching asset category could not be found 2404 */ 2405 public AssetCategory findByG_P_N_V_Last(long groupId, 2406 long parentCategoryId, java.lang.String name, long vocabularyId, 2407 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 2408 throws NoSuchCategoryException; 2409 2410 /** 2411 * Returns the last asset category in the ordered set where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2412 * 2413 * @param groupId the group ID 2414 * @param parentCategoryId the parent category ID 2415 * @param name the name 2416 * @param vocabularyId the vocabulary ID 2417 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2418 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 2419 */ 2420 public AssetCategory fetchByG_P_N_V_Last(long groupId, 2421 long parentCategoryId, java.lang.String name, long vocabularyId, 2422 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 2423 2424 /** 2425 * Returns the asset categories before and after the current asset category in the ordered set where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2426 * 2427 * @param categoryId the primary key of the current asset category 2428 * @param groupId the group ID 2429 * @param parentCategoryId the parent category ID 2430 * @param name the name 2431 * @param vocabularyId the vocabulary ID 2432 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2433 * @return the previous, current, and next asset category 2434 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 2435 */ 2436 public AssetCategory[] findByG_P_N_V_PrevAndNext(long categoryId, 2437 long groupId, long parentCategoryId, java.lang.String name, 2438 long vocabularyId, 2439 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 2440 throws NoSuchCategoryException; 2441 2442 /** 2443 * Returns all the asset categories that the user has permission to view where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2444 * 2445 * @param groupId the group ID 2446 * @param parentCategoryId the parent category ID 2447 * @param name the name 2448 * @param vocabularyId the vocabulary ID 2449 * @return the matching asset categories that the user has permission to view 2450 */ 2451 public java.util.List<AssetCategory> filterFindByG_P_N_V(long groupId, 2452 long parentCategoryId, java.lang.String name, long vocabularyId); 2453 2454 /** 2455 * Returns a range of all the asset categories that the user has permission to view where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2456 * 2457 * <p> 2458 * 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 AssetCategoryModelImpl}. 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. 2459 * </p> 2460 * 2461 * @param groupId the group ID 2462 * @param parentCategoryId the parent category ID 2463 * @param name the name 2464 * @param vocabularyId the vocabulary ID 2465 * @param start the lower bound of the range of asset categories 2466 * @param end the upper bound of the range of asset categories (not inclusive) 2467 * @return the range of matching asset categories that the user has permission to view 2468 */ 2469 public java.util.List<AssetCategory> filterFindByG_P_N_V(long groupId, 2470 long parentCategoryId, java.lang.String name, long vocabularyId, 2471 int start, int end); 2472 2473 /** 2474 * Returns an ordered range of all the asset categories that the user has permissions to view where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2475 * 2476 * <p> 2477 * 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 AssetCategoryModelImpl}. 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. 2478 * </p> 2479 * 2480 * @param groupId the group ID 2481 * @param parentCategoryId the parent category ID 2482 * @param name the name 2483 * @param vocabularyId the vocabulary ID 2484 * @param start the lower bound of the range of asset categories 2485 * @param end the upper bound of the range of asset categories (not inclusive) 2486 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2487 * @return the ordered range of matching asset categories that the user has permission to view 2488 */ 2489 public java.util.List<AssetCategory> filterFindByG_P_N_V(long groupId, 2490 long parentCategoryId, java.lang.String name, long vocabularyId, 2491 int start, int end, 2492 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 2493 2494 /** 2495 * Returns the asset categories before and after the current asset category in the ordered set of asset categories that the user has permission to view where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2496 * 2497 * @param categoryId the primary key of the current asset category 2498 * @param groupId the group ID 2499 * @param parentCategoryId the parent category ID 2500 * @param name the name 2501 * @param vocabularyId the vocabulary ID 2502 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2503 * @return the previous, current, and next asset category 2504 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 2505 */ 2506 public AssetCategory[] filterFindByG_P_N_V_PrevAndNext(long categoryId, 2507 long groupId, long parentCategoryId, java.lang.String name, 2508 long vocabularyId, 2509 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 2510 throws NoSuchCategoryException; 2511 2512 /** 2513 * Removes all the asset categories where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ? from the database. 2514 * 2515 * @param groupId the group ID 2516 * @param parentCategoryId the parent category ID 2517 * @param name the name 2518 * @param vocabularyId the vocabulary ID 2519 */ 2520 public void removeByG_P_N_V(long groupId, long parentCategoryId, 2521 java.lang.String name, long vocabularyId); 2522 2523 /** 2524 * Returns the number of asset categories where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2525 * 2526 * @param groupId the group ID 2527 * @param parentCategoryId the parent category ID 2528 * @param name the name 2529 * @param vocabularyId the vocabulary ID 2530 * @return the number of matching asset categories 2531 */ 2532 public int countByG_P_N_V(long groupId, long parentCategoryId, 2533 java.lang.String name, long vocabularyId); 2534 2535 /** 2536 * Returns the number of asset categories that the user has permission to view where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2537 * 2538 * @param groupId the group ID 2539 * @param parentCategoryId the parent category ID 2540 * @param name the name 2541 * @param vocabularyId the vocabulary ID 2542 * @return the number of matching asset categories that the user has permission to view 2543 */ 2544 public int filterCountByG_P_N_V(long groupId, long parentCategoryId, 2545 java.lang.String name, long vocabularyId); 2546 2547 /** 2548 * Caches the asset category in the entity cache if it is enabled. 2549 * 2550 * @param assetCategory the asset category 2551 */ 2552 public void cacheResult(AssetCategory assetCategory); 2553 2554 /** 2555 * Caches the asset categories in the entity cache if it is enabled. 2556 * 2557 * @param assetCategories the asset categories 2558 */ 2559 public void cacheResult(java.util.List<AssetCategory> assetCategories); 2560 2561 /** 2562 * Creates a new asset category with the primary key. Does not add the asset category to the database. 2563 * 2564 * @param categoryId the primary key for the new asset category 2565 * @return the new asset category 2566 */ 2567 public AssetCategory create(long categoryId); 2568 2569 /** 2570 * Removes the asset category with the primary key from the database. Also notifies the appropriate model listeners. 2571 * 2572 * @param categoryId the primary key of the asset category 2573 * @return the asset category that was removed 2574 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 2575 */ 2576 public AssetCategory remove(long categoryId) throws NoSuchCategoryException; 2577 2578 public AssetCategory updateImpl(AssetCategory assetCategory); 2579 2580 /** 2581 * Returns the asset category with the primary key or throws a {@link NoSuchCategoryException} if it could not be found. 2582 * 2583 * @param categoryId the primary key of the asset category 2584 * @return the asset category 2585 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 2586 */ 2587 public AssetCategory findByPrimaryKey(long categoryId) 2588 throws NoSuchCategoryException; 2589 2590 /** 2591 * Returns the asset category with the primary key or returns <code>null</code> if it could not be found. 2592 * 2593 * @param categoryId the primary key of the asset category 2594 * @return the asset category, or <code>null</code> if a asset category with the primary key could not be found 2595 */ 2596 public AssetCategory fetchByPrimaryKey(long categoryId); 2597 2598 @Override 2599 public java.util.Map<java.io.Serializable, AssetCategory> fetchByPrimaryKeys( 2600 java.util.Set<java.io.Serializable> primaryKeys); 2601 2602 /** 2603 * Returns all the asset categories. 2604 * 2605 * @return the asset categories 2606 */ 2607 public java.util.List<AssetCategory> findAll(); 2608 2609 /** 2610 * Returns a range of all the asset categories. 2611 * 2612 * <p> 2613 * 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 AssetCategoryModelImpl}. 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. 2614 * </p> 2615 * 2616 * @param start the lower bound of the range of asset categories 2617 * @param end the upper bound of the range of asset categories (not inclusive) 2618 * @return the range of asset categories 2619 */ 2620 public java.util.List<AssetCategory> findAll(int start, int end); 2621 2622 /** 2623 * Returns an ordered range of all the asset categories. 2624 * 2625 * <p> 2626 * 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 AssetCategoryModelImpl}. 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. 2627 * </p> 2628 * 2629 * @param start the lower bound of the range of asset categories 2630 * @param end the upper bound of the range of asset categories (not inclusive) 2631 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2632 * @return the ordered range of asset categories 2633 */ 2634 public java.util.List<AssetCategory> findAll(int start, int end, 2635 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 2636 2637 /** 2638 * Returns an ordered range of all the asset categories. 2639 * 2640 * <p> 2641 * 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 AssetCategoryModelImpl}. 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. 2642 * </p> 2643 * 2644 * @param start the lower bound of the range of asset categories 2645 * @param end the upper bound of the range of asset categories (not inclusive) 2646 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2647 * @param retrieveFromCache whether to retrieve from the finder cache 2648 * @return the ordered range of asset categories 2649 */ 2650 public java.util.List<AssetCategory> findAll(int start, int end, 2651 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator, 2652 boolean retrieveFromCache); 2653 2654 /** 2655 * Removes all the asset categories from the database. 2656 */ 2657 public void removeAll(); 2658 2659 /** 2660 * Returns the number of asset categories. 2661 * 2662 * @return the number of asset categories 2663 */ 2664 public int countAll(); 2665 2666 /** 2667 * Returns the primaryKeys of asset entries associated with the asset category. 2668 * 2669 * @param pk the primary key of the asset category 2670 * @return long[] of the primaryKeys of asset entries associated with the asset category 2671 */ 2672 public long[] getAssetEntryPrimaryKeys(long pk); 2673 2674 /** 2675 * Returns all the asset entries associated with the asset category. 2676 * 2677 * @param pk the primary key of the asset category 2678 * @return the asset entries associated with the asset category 2679 */ 2680 public java.util.List<com.liferay.asset.kernel.model.AssetEntry> getAssetEntries( 2681 long pk); 2682 2683 /** 2684 * Returns a range of all the asset entries associated with the asset category. 2685 * 2686 * <p> 2687 * 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 AssetCategoryModelImpl}. 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. 2688 * </p> 2689 * 2690 * @param pk the primary key of the asset category 2691 * @param start the lower bound of the range of asset categories 2692 * @param end the upper bound of the range of asset categories (not inclusive) 2693 * @return the range of asset entries associated with the asset category 2694 */ 2695 public java.util.List<com.liferay.asset.kernel.model.AssetEntry> getAssetEntries( 2696 long pk, int start, int end); 2697 2698 /** 2699 * Returns an ordered range of all the asset entries associated with the asset category. 2700 * 2701 * <p> 2702 * 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 AssetCategoryModelImpl}. 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. 2703 * </p> 2704 * 2705 * @param pk the primary key of the asset category 2706 * @param start the lower bound of the range of asset categories 2707 * @param end the upper bound of the range of asset categories (not inclusive) 2708 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2709 * @return the ordered range of asset entries associated with the asset category 2710 */ 2711 public java.util.List<com.liferay.asset.kernel.model.AssetEntry> getAssetEntries( 2712 long pk, int start, int end, 2713 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.asset.kernel.model.AssetEntry> orderByComparator); 2714 2715 /** 2716 * Returns the number of asset entries associated with the asset category. 2717 * 2718 * @param pk the primary key of the asset category 2719 * @return the number of asset entries associated with the asset category 2720 */ 2721 public int getAssetEntriesSize(long pk); 2722 2723 /** 2724 * Returns <code>true</code> if the asset entry is associated with the asset category. 2725 * 2726 * @param pk the primary key of the asset category 2727 * @param assetEntryPK the primary key of the asset entry 2728 * @return <code>true</code> if the asset entry is associated with the asset category; <code>false</code> otherwise 2729 */ 2730 public boolean containsAssetEntry(long pk, long assetEntryPK); 2731 2732 /** 2733 * Returns <code>true</code> if the asset category has any asset entries associated with it. 2734 * 2735 * @param pk the primary key of the asset category to check for associations with asset entries 2736 * @return <code>true</code> if the asset category has any asset entries associated with it; <code>false</code> otherwise 2737 */ 2738 public boolean containsAssetEntries(long pk); 2739 2740 /** 2741 * Adds an association between the asset category and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2742 * 2743 * @param pk the primary key of the asset category 2744 * @param assetEntryPK the primary key of the asset entry 2745 */ 2746 public void addAssetEntry(long pk, long assetEntryPK); 2747 2748 /** 2749 * Adds an association between the asset category and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2750 * 2751 * @param pk the primary key of the asset category 2752 * @param assetEntry the asset entry 2753 */ 2754 public void addAssetEntry(long pk, 2755 com.liferay.asset.kernel.model.AssetEntry assetEntry); 2756 2757 /** 2758 * Adds an association between the asset category and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2759 * 2760 * @param pk the primary key of the asset category 2761 * @param assetEntryPKs the primary keys of the asset entries 2762 */ 2763 public void addAssetEntries(long pk, long[] assetEntryPKs); 2764 2765 /** 2766 * Adds an association between the asset category and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2767 * 2768 * @param pk the primary key of the asset category 2769 * @param assetEntries the asset entries 2770 */ 2771 public void addAssetEntries(long pk, 2772 java.util.List<com.liferay.asset.kernel.model.AssetEntry> assetEntries); 2773 2774 /** 2775 * Clears all associations between the asset category and its asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2776 * 2777 * @param pk the primary key of the asset category to clear the associated asset entries from 2778 */ 2779 public void clearAssetEntries(long pk); 2780 2781 /** 2782 * Removes the association between the asset category and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2783 * 2784 * @param pk the primary key of the asset category 2785 * @param assetEntryPK the primary key of the asset entry 2786 */ 2787 public void removeAssetEntry(long pk, long assetEntryPK); 2788 2789 /** 2790 * Removes the association between the asset category and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2791 * 2792 * @param pk the primary key of the asset category 2793 * @param assetEntry the asset entry 2794 */ 2795 public void removeAssetEntry(long pk, 2796 com.liferay.asset.kernel.model.AssetEntry assetEntry); 2797 2798 /** 2799 * Removes the association between the asset category and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2800 * 2801 * @param pk the primary key of the asset category 2802 * @param assetEntryPKs the primary keys of the asset entries 2803 */ 2804 public void removeAssetEntries(long pk, long[] assetEntryPKs); 2805 2806 /** 2807 * Removes the association between the asset category and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2808 * 2809 * @param pk the primary key of the asset category 2810 * @param assetEntries the asset entries 2811 */ 2812 public void removeAssetEntries(long pk, 2813 java.util.List<com.liferay.asset.kernel.model.AssetEntry> assetEntries); 2814 2815 /** 2816 * Sets the asset entries associated with the asset category, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2817 * 2818 * @param pk the primary key of the asset category 2819 * @param assetEntryPKs the primary keys of the asset entries to be associated with the asset category 2820 */ 2821 public void setAssetEntries(long pk, long[] assetEntryPKs); 2822 2823 /** 2824 * Sets the asset entries associated with the asset category, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2825 * 2826 * @param pk the primary key of the asset category 2827 * @param assetEntries the asset entries to be associated with the asset category 2828 */ 2829 public void setAssetEntries(long pk, 2830 java.util.List<com.liferay.asset.kernel.model.AssetEntry> assetEntries); 2831 2832 @Override 2833 public java.util.Set<java.lang.String> getBadColumnNames(); 2834 2835 public long countAncestors(AssetCategory assetCategory); 2836 2837 public long countDescendants(AssetCategory assetCategory); 2838 2839 public java.util.List<AssetCategory> getAncestors( 2840 AssetCategory assetCategory); 2841 2842 public java.util.List<AssetCategory> getDescendants( 2843 AssetCategory assetCategory); 2844 2845 /** 2846 * Rebuilds the asset categories tree for the scope using the modified pre-order tree traversal algorithm. 2847 * 2848 * <p> 2849 * Only call this method if the tree has become stale through operations other than normal CRUD. Under normal circumstances the tree is automatically rebuilt whenver necessary. 2850 * </p> 2851 * 2852 * @param groupId the ID of the scope 2853 * @param force whether to force the rebuild even if the tree is not stale 2854 */ 2855 public void rebuildTree(long groupId, boolean force); 2856 2857 public void setRebuildTreeEnabled(boolean rebuildTreeEnabled); 2858 }