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