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.kernel.bean.PortalBeanLocatorUtil; 020 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 021 import com.liferay.portal.kernel.util.OrderByComparator; 022 import com.liferay.portal.kernel.util.ReferenceRegistry; 023 import com.liferay.portal.service.ServiceContext; 024 025 import com.liferay.portlet.asset.model.AssetCategory; 026 027 import java.util.List; 028 029 /** 030 * The persistence utility for the asset category service. This utility wraps {@link com.liferay.portlet.asset.service.persistence.impl.AssetCategoryPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 031 * 032 * <p> 033 * Caching information and settings can be found in <code>portal.properties</code> 034 * </p> 035 * 036 * @author Brian Wing Shun Chan 037 * @see AssetCategoryPersistence 038 * @see com.liferay.portlet.asset.service.persistence.impl.AssetCategoryPersistenceImpl 039 * @generated 040 */ 041 @ProviderType 042 public class AssetCategoryUtil { 043 /* 044 * NOTE FOR DEVELOPERS: 045 * 046 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 047 */ 048 049 /** 050 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 051 */ 052 public static void clearCache() { 053 getPersistence().clearCache(); 054 } 055 056 /** 057 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 058 */ 059 public static void clearCache(AssetCategory assetCategory) { 060 getPersistence().clearCache(assetCategory); 061 } 062 063 /** 064 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 065 */ 066 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) { 067 return getPersistence().countWithDynamicQuery(dynamicQuery); 068 } 069 070 /** 071 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 072 */ 073 public static List<AssetCategory> findWithDynamicQuery( 074 DynamicQuery dynamicQuery) { 075 return getPersistence().findWithDynamicQuery(dynamicQuery); 076 } 077 078 /** 079 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 080 */ 081 public static List<AssetCategory> findWithDynamicQuery( 082 DynamicQuery dynamicQuery, int start, int end) { 083 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 084 } 085 086 /** 087 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 088 */ 089 public static List<AssetCategory> findWithDynamicQuery( 090 DynamicQuery dynamicQuery, int start, int end, 091 OrderByComparator<AssetCategory> orderByComparator) { 092 return getPersistence() 093 .findWithDynamicQuery(dynamicQuery, start, end, 094 orderByComparator); 095 } 096 097 /** 098 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 099 */ 100 public static AssetCategory update(AssetCategory assetCategory) { 101 return getPersistence().update(assetCategory); 102 } 103 104 /** 105 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 106 */ 107 public static AssetCategory update(AssetCategory assetCategory, 108 ServiceContext serviceContext) { 109 return getPersistence().update(assetCategory, serviceContext); 110 } 111 112 /** 113 * Returns all the asset categories where uuid = ?. 114 * 115 * @param uuid the uuid 116 * @return the matching asset categories 117 */ 118 public static List<AssetCategory> findByUuid(java.lang.String uuid) { 119 return getPersistence().findByUuid(uuid); 120 } 121 122 /** 123 * Returns a range of all the asset categories where uuid = ?. 124 * 125 * <p> 126 * 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. 127 * </p> 128 * 129 * @param uuid the uuid 130 * @param start the lower bound of the range of asset categories 131 * @param end the upper bound of the range of asset categories (not inclusive) 132 * @return the range of matching asset categories 133 */ 134 public static List<AssetCategory> findByUuid(java.lang.String uuid, 135 int start, int end) { 136 return getPersistence().findByUuid(uuid, start, end); 137 } 138 139 /** 140 * Returns an ordered range of all the asset categories where uuid = ?. 141 * 142 * <p> 143 * 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. 144 * </p> 145 * 146 * @param uuid the uuid 147 * @param start the lower bound of the range of asset categories 148 * @param end the upper bound of the range of asset categories (not inclusive) 149 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 150 * @return the ordered range of matching asset categories 151 */ 152 public static List<AssetCategory> findByUuid(java.lang.String uuid, 153 int start, int end, OrderByComparator<AssetCategory> orderByComparator) { 154 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 155 } 156 157 /** 158 * Returns an ordered range of all the asset categories where uuid = ?. 159 * 160 * <p> 161 * 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. 162 * </p> 163 * 164 * @param uuid the uuid 165 * @param start the lower bound of the range of asset categories 166 * @param end the upper bound of the range of asset categories (not inclusive) 167 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 168 * @param retrieveFromCache whether to retrieve from the finder cache 169 * @return the ordered range of matching asset categories 170 */ 171 public static List<AssetCategory> findByUuid(java.lang.String uuid, 172 int start, int end, OrderByComparator<AssetCategory> orderByComparator, 173 boolean retrieveFromCache) { 174 return getPersistence() 175 .findByUuid(uuid, start, end, orderByComparator, 176 retrieveFromCache); 177 } 178 179 /** 180 * Returns the first asset category in the ordered set where uuid = ?. 181 * 182 * @param uuid the uuid 183 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 184 * @return the first matching asset category 185 * @throws NoSuchCategoryException if a matching asset category could not be found 186 */ 187 public static AssetCategory findByUuid_First(java.lang.String uuid, 188 OrderByComparator<AssetCategory> orderByComparator) 189 throws com.liferay.portlet.asset.NoSuchCategoryException { 190 return getPersistence().findByUuid_First(uuid, orderByComparator); 191 } 192 193 /** 194 * Returns the first asset category in the ordered set where uuid = ?. 195 * 196 * @param uuid the uuid 197 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 198 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 199 */ 200 public static AssetCategory fetchByUuid_First(java.lang.String uuid, 201 OrderByComparator<AssetCategory> orderByComparator) { 202 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 203 } 204 205 /** 206 * Returns the last asset category in the ordered set where uuid = ?. 207 * 208 * @param uuid the uuid 209 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 210 * @return the last matching asset category 211 * @throws NoSuchCategoryException if a matching asset category could not be found 212 */ 213 public static AssetCategory findByUuid_Last(java.lang.String uuid, 214 OrderByComparator<AssetCategory> orderByComparator) 215 throws com.liferay.portlet.asset.NoSuchCategoryException { 216 return getPersistence().findByUuid_Last(uuid, orderByComparator); 217 } 218 219 /** 220 * Returns the last asset category in the ordered set where uuid = ?. 221 * 222 * @param uuid the uuid 223 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 224 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 225 */ 226 public static AssetCategory fetchByUuid_Last(java.lang.String uuid, 227 OrderByComparator<AssetCategory> orderByComparator) { 228 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 229 } 230 231 /** 232 * Returns the asset categories before and after the current asset category in the ordered set where uuid = ?. 233 * 234 * @param categoryId the primary key of the current asset category 235 * @param uuid the uuid 236 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 237 * @return the previous, current, and next asset category 238 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 239 */ 240 public static AssetCategory[] findByUuid_PrevAndNext(long categoryId, 241 java.lang.String uuid, 242 OrderByComparator<AssetCategory> orderByComparator) 243 throws com.liferay.portlet.asset.NoSuchCategoryException { 244 return getPersistence() 245 .findByUuid_PrevAndNext(categoryId, uuid, orderByComparator); 246 } 247 248 /** 249 * Removes all the asset categories where uuid = ? from the database. 250 * 251 * @param uuid the uuid 252 */ 253 public static void removeByUuid(java.lang.String uuid) { 254 getPersistence().removeByUuid(uuid); 255 } 256 257 /** 258 * Returns the number of asset categories where uuid = ?. 259 * 260 * @param uuid the uuid 261 * @return the number of matching asset categories 262 */ 263 public static int countByUuid(java.lang.String uuid) { 264 return getPersistence().countByUuid(uuid); 265 } 266 267 /** 268 * Returns the asset category where uuid = ? and groupId = ? or throws a {@link NoSuchCategoryException} if it could not be found. 269 * 270 * @param uuid the uuid 271 * @param groupId the group ID 272 * @return the matching asset category 273 * @throws NoSuchCategoryException if a matching asset category could not be found 274 */ 275 public static AssetCategory findByUUID_G(java.lang.String uuid, long groupId) 276 throws com.liferay.portlet.asset.NoSuchCategoryException { 277 return getPersistence().findByUUID_G(uuid, groupId); 278 } 279 280 /** 281 * Returns the asset category where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 282 * 283 * @param uuid the uuid 284 * @param groupId the group ID 285 * @return the matching asset category, or <code>null</code> if a matching asset category could not be found 286 */ 287 public static AssetCategory fetchByUUID_G(java.lang.String uuid, 288 long groupId) { 289 return getPersistence().fetchByUUID_G(uuid, groupId); 290 } 291 292 /** 293 * Returns the asset category where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 294 * 295 * @param uuid the uuid 296 * @param groupId the group ID 297 * @param retrieveFromCache whether to retrieve from the finder cache 298 * @return the matching asset category, or <code>null</code> if a matching asset category could not be found 299 */ 300 public static AssetCategory fetchByUUID_G(java.lang.String uuid, 301 long groupId, boolean retrieveFromCache) { 302 return getPersistence().fetchByUUID_G(uuid, groupId, retrieveFromCache); 303 } 304 305 /** 306 * Removes the asset category where uuid = ? and groupId = ? from the database. 307 * 308 * @param uuid the uuid 309 * @param groupId the group ID 310 * @return the asset category that was removed 311 */ 312 public static AssetCategory removeByUUID_G(java.lang.String uuid, 313 long groupId) throws com.liferay.portlet.asset.NoSuchCategoryException { 314 return getPersistence().removeByUUID_G(uuid, groupId); 315 } 316 317 /** 318 * Returns the number of asset categories where uuid = ? and groupId = ?. 319 * 320 * @param uuid the uuid 321 * @param groupId the group ID 322 * @return the number of matching asset categories 323 */ 324 public static int countByUUID_G(java.lang.String uuid, long groupId) { 325 return getPersistence().countByUUID_G(uuid, groupId); 326 } 327 328 /** 329 * Returns all the asset categories where uuid = ? and companyId = ?. 330 * 331 * @param uuid the uuid 332 * @param companyId the company ID 333 * @return the matching asset categories 334 */ 335 public static List<AssetCategory> findByUuid_C(java.lang.String uuid, 336 long companyId) { 337 return getPersistence().findByUuid_C(uuid, companyId); 338 } 339 340 /** 341 * Returns a range of all the asset categories where uuid = ? and companyId = ?. 342 * 343 * <p> 344 * 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. 345 * </p> 346 * 347 * @param uuid the uuid 348 * @param companyId the company ID 349 * @param start the lower bound of the range of asset categories 350 * @param end the upper bound of the range of asset categories (not inclusive) 351 * @return the range of matching asset categories 352 */ 353 public static List<AssetCategory> findByUuid_C(java.lang.String uuid, 354 long companyId, int start, int end) { 355 return getPersistence().findByUuid_C(uuid, companyId, start, end); 356 } 357 358 /** 359 * Returns an ordered range of all the asset categories where uuid = ? and companyId = ?. 360 * 361 * <p> 362 * 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. 363 * </p> 364 * 365 * @param uuid the uuid 366 * @param companyId the company ID 367 * @param start the lower bound of the range of asset categories 368 * @param end the upper bound of the range of asset categories (not inclusive) 369 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 370 * @return the ordered range of matching asset categories 371 */ 372 public static List<AssetCategory> findByUuid_C(java.lang.String uuid, 373 long companyId, int start, int end, 374 OrderByComparator<AssetCategory> orderByComparator) { 375 return getPersistence() 376 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 377 } 378 379 /** 380 * Returns an ordered range of all the asset categories where uuid = ? and companyId = ?. 381 * 382 * <p> 383 * 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. 384 * </p> 385 * 386 * @param uuid the uuid 387 * @param companyId the company ID 388 * @param start the lower bound of the range of asset categories 389 * @param end the upper bound of the range of asset categories (not inclusive) 390 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 391 * @param retrieveFromCache whether to retrieve from the finder cache 392 * @return the ordered range of matching asset categories 393 */ 394 public static List<AssetCategory> findByUuid_C(java.lang.String uuid, 395 long companyId, int start, int end, 396 OrderByComparator<AssetCategory> orderByComparator, 397 boolean retrieveFromCache) { 398 return getPersistence() 399 .findByUuid_C(uuid, companyId, start, end, 400 orderByComparator, retrieveFromCache); 401 } 402 403 /** 404 * Returns the first asset category in the ordered set where uuid = ? and companyId = ?. 405 * 406 * @param uuid the uuid 407 * @param companyId the company ID 408 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 409 * @return the first matching asset category 410 * @throws NoSuchCategoryException if a matching asset category could not be found 411 */ 412 public static AssetCategory findByUuid_C_First(java.lang.String uuid, 413 long companyId, OrderByComparator<AssetCategory> orderByComparator) 414 throws com.liferay.portlet.asset.NoSuchCategoryException { 415 return getPersistence() 416 .findByUuid_C_First(uuid, companyId, orderByComparator); 417 } 418 419 /** 420 * Returns the first asset category in the ordered set where uuid = ? and companyId = ?. 421 * 422 * @param uuid the uuid 423 * @param companyId the company ID 424 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 425 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 426 */ 427 public static AssetCategory fetchByUuid_C_First(java.lang.String uuid, 428 long companyId, OrderByComparator<AssetCategory> orderByComparator) { 429 return getPersistence() 430 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 431 } 432 433 /** 434 * Returns the last asset category in the ordered set where uuid = ? and companyId = ?. 435 * 436 * @param uuid the uuid 437 * @param companyId the company ID 438 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 439 * @return the last matching asset category 440 * @throws NoSuchCategoryException if a matching asset category could not be found 441 */ 442 public static AssetCategory findByUuid_C_Last(java.lang.String uuid, 443 long companyId, OrderByComparator<AssetCategory> orderByComparator) 444 throws com.liferay.portlet.asset.NoSuchCategoryException { 445 return getPersistence() 446 .findByUuid_C_Last(uuid, companyId, orderByComparator); 447 } 448 449 /** 450 * Returns the last asset category in the ordered set where uuid = ? and companyId = ?. 451 * 452 * @param uuid the uuid 453 * @param companyId the company ID 454 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 455 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 456 */ 457 public static AssetCategory fetchByUuid_C_Last(java.lang.String uuid, 458 long companyId, OrderByComparator<AssetCategory> orderByComparator) { 459 return getPersistence() 460 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 461 } 462 463 /** 464 * Returns the asset categories before and after the current asset category in the ordered set where uuid = ? and companyId = ?. 465 * 466 * @param categoryId the primary key of the current asset category 467 * @param uuid the uuid 468 * @param companyId the company ID 469 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 470 * @return the previous, current, and next asset category 471 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 472 */ 473 public static AssetCategory[] findByUuid_C_PrevAndNext(long categoryId, 474 java.lang.String uuid, long companyId, 475 OrderByComparator<AssetCategory> orderByComparator) 476 throws com.liferay.portlet.asset.NoSuchCategoryException { 477 return getPersistence() 478 .findByUuid_C_PrevAndNext(categoryId, uuid, companyId, 479 orderByComparator); 480 } 481 482 /** 483 * Removes all the asset categories where uuid = ? and companyId = ? from the database. 484 * 485 * @param uuid the uuid 486 * @param companyId the company ID 487 */ 488 public static void removeByUuid_C(java.lang.String uuid, long companyId) { 489 getPersistence().removeByUuid_C(uuid, companyId); 490 } 491 492 /** 493 * Returns the number of asset categories where uuid = ? and companyId = ?. 494 * 495 * @param uuid the uuid 496 * @param companyId the company ID 497 * @return the number of matching asset categories 498 */ 499 public static int countByUuid_C(java.lang.String uuid, long companyId) { 500 return getPersistence().countByUuid_C(uuid, companyId); 501 } 502 503 /** 504 * Returns all the asset categories where groupId = ?. 505 * 506 * @param groupId the group ID 507 * @return the matching asset categories 508 */ 509 public static List<AssetCategory> findByGroupId(long groupId) { 510 return getPersistence().findByGroupId(groupId); 511 } 512 513 /** 514 * Returns a range of all the asset categories 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 * @return the range of matching asset categories 524 */ 525 public static List<AssetCategory> findByGroupId(long groupId, int start, 526 int end) { 527 return getPersistence().findByGroupId(groupId, start, end); 528 } 529 530 /** 531 * Returns an ordered range of all the asset categories where groupId = ?. 532 * 533 * <p> 534 * 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. 535 * </p> 536 * 537 * @param groupId the group ID 538 * @param start the lower bound of the range of asset categories 539 * @param end the upper bound of the range of asset categories (not inclusive) 540 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 541 * @return the ordered range of matching asset categories 542 */ 543 public static List<AssetCategory> findByGroupId(long groupId, int start, 544 int end, OrderByComparator<AssetCategory> orderByComparator) { 545 return getPersistence() 546 .findByGroupId(groupId, start, end, orderByComparator); 547 } 548 549 /** 550 * Returns an ordered range of all the asset categories where groupId = ?. 551 * 552 * <p> 553 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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. 554 * </p> 555 * 556 * @param groupId the group ID 557 * @param start the lower bound of the range of asset categories 558 * @param end the upper bound of the range of asset categories (not inclusive) 559 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 560 * @param retrieveFromCache whether to retrieve from the finder cache 561 * @return the ordered range of matching asset categories 562 */ 563 public static List<AssetCategory> findByGroupId(long groupId, int start, 564 int end, OrderByComparator<AssetCategory> orderByComparator, 565 boolean retrieveFromCache) { 566 return getPersistence() 567 .findByGroupId(groupId, start, end, orderByComparator, 568 retrieveFromCache); 569 } 570 571 /** 572 * Returns the first asset category in the ordered set where groupId = ?. 573 * 574 * @param groupId the group ID 575 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 576 * @return the first matching asset category 577 * @throws NoSuchCategoryException if a matching asset category could not be found 578 */ 579 public static AssetCategory findByGroupId_First(long groupId, 580 OrderByComparator<AssetCategory> orderByComparator) 581 throws com.liferay.portlet.asset.NoSuchCategoryException { 582 return getPersistence().findByGroupId_First(groupId, orderByComparator); 583 } 584 585 /** 586 * Returns the first asset category in the ordered set where groupId = ?. 587 * 588 * @param groupId the group ID 589 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 590 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 591 */ 592 public static AssetCategory fetchByGroupId_First(long groupId, 593 OrderByComparator<AssetCategory> orderByComparator) { 594 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 595 } 596 597 /** 598 * Returns the last asset category in the ordered set where groupId = ?. 599 * 600 * @param groupId the group ID 601 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 602 * @return the last matching asset category 603 * @throws NoSuchCategoryException if a matching asset category could not be found 604 */ 605 public static AssetCategory findByGroupId_Last(long groupId, 606 OrderByComparator<AssetCategory> orderByComparator) 607 throws com.liferay.portlet.asset.NoSuchCategoryException { 608 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 609 } 610 611 /** 612 * Returns the last asset category in the ordered set where groupId = ?. 613 * 614 * @param groupId the group ID 615 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 616 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 617 */ 618 public static AssetCategory fetchByGroupId_Last(long groupId, 619 OrderByComparator<AssetCategory> orderByComparator) { 620 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 621 } 622 623 /** 624 * Returns the asset categories before and after the current asset category in the ordered set where groupId = ?. 625 * 626 * @param categoryId the primary key of the current asset category 627 * @param groupId the group ID 628 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 629 * @return the previous, current, and next asset category 630 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 631 */ 632 public static AssetCategory[] findByGroupId_PrevAndNext(long categoryId, 633 long groupId, OrderByComparator<AssetCategory> orderByComparator) 634 throws com.liferay.portlet.asset.NoSuchCategoryException { 635 return getPersistence() 636 .findByGroupId_PrevAndNext(categoryId, groupId, 637 orderByComparator); 638 } 639 640 /** 641 * Returns all the asset categories that the user has permission to view where groupId = ?. 642 * 643 * @param groupId the group ID 644 * @return the matching asset categories that the user has permission to view 645 */ 646 public static List<AssetCategory> filterFindByGroupId(long groupId) { 647 return getPersistence().filterFindByGroupId(groupId); 648 } 649 650 /** 651 * Returns a range of all the asset categories that the user has permission to view where groupId = ?. 652 * 653 * <p> 654 * 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. 655 * </p> 656 * 657 * @param groupId the group ID 658 * @param start the lower bound of the range of asset categories 659 * @param end the upper bound of the range of asset categories (not inclusive) 660 * @return the range of matching asset categories that the user has permission to view 661 */ 662 public static List<AssetCategory> filterFindByGroupId(long groupId, 663 int start, int end) { 664 return getPersistence().filterFindByGroupId(groupId, start, end); 665 } 666 667 /** 668 * Returns an ordered range of all the asset categories that the user has permissions to view where groupId = ?. 669 * 670 * <p> 671 * 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. 672 * </p> 673 * 674 * @param groupId the group ID 675 * @param start the lower bound of the range of asset categories 676 * @param end the upper bound of the range of asset categories (not inclusive) 677 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 678 * @return the ordered range of matching asset categories that the user has permission to view 679 */ 680 public static List<AssetCategory> filterFindByGroupId(long groupId, 681 int start, int end, OrderByComparator<AssetCategory> orderByComparator) { 682 return getPersistence() 683 .filterFindByGroupId(groupId, start, end, orderByComparator); 684 } 685 686 /** 687 * 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 = ?. 688 * 689 * @param categoryId the primary key of the current asset category 690 * @param groupId the group ID 691 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 692 * @return the previous, current, and next asset category 693 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 694 */ 695 public static AssetCategory[] filterFindByGroupId_PrevAndNext( 696 long categoryId, long groupId, 697 OrderByComparator<AssetCategory> orderByComparator) 698 throws com.liferay.portlet.asset.NoSuchCategoryException { 699 return getPersistence() 700 .filterFindByGroupId_PrevAndNext(categoryId, groupId, 701 orderByComparator); 702 } 703 704 /** 705 * Removes all the asset categories where groupId = ? from the database. 706 * 707 * @param groupId the group ID 708 */ 709 public static void removeByGroupId(long groupId) { 710 getPersistence().removeByGroupId(groupId); 711 } 712 713 /** 714 * Returns the number of asset categories where groupId = ?. 715 * 716 * @param groupId the group ID 717 * @return the number of matching asset categories 718 */ 719 public static int countByGroupId(long groupId) { 720 return getPersistence().countByGroupId(groupId); 721 } 722 723 /** 724 * Returns the number of asset categories that the user has permission to view where groupId = ?. 725 * 726 * @param groupId the group ID 727 * @return the number of matching asset categories that the user has permission to view 728 */ 729 public static int filterCountByGroupId(long groupId) { 730 return getPersistence().filterCountByGroupId(groupId); 731 } 732 733 /** 734 * Returns all the asset categories where parentCategoryId = ?. 735 * 736 * @param parentCategoryId the parent category ID 737 * @return the matching asset categories 738 */ 739 public static List<AssetCategory> findByParentCategoryId( 740 long parentCategoryId) { 741 return getPersistence().findByParentCategoryId(parentCategoryId); 742 } 743 744 /** 745 * Returns a range of all the asset categories where parentCategoryId = ?. 746 * 747 * <p> 748 * 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. 749 * </p> 750 * 751 * @param parentCategoryId the parent category ID 752 * @param start the lower bound of the range of asset categories 753 * @param end the upper bound of the range of asset categories (not inclusive) 754 * @return the range of matching asset categories 755 */ 756 public static List<AssetCategory> findByParentCategoryId( 757 long parentCategoryId, int start, int end) { 758 return getPersistence() 759 .findByParentCategoryId(parentCategoryId, start, end); 760 } 761 762 /** 763 * Returns an ordered range of all the asset categories where parentCategoryId = ?. 764 * 765 * <p> 766 * 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. 767 * </p> 768 * 769 * @param parentCategoryId the parent category ID 770 * @param start the lower bound of the range of asset categories 771 * @param end the upper bound of the range of asset categories (not inclusive) 772 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 773 * @return the ordered range of matching asset categories 774 */ 775 public static List<AssetCategory> findByParentCategoryId( 776 long parentCategoryId, int start, int end, 777 OrderByComparator<AssetCategory> orderByComparator) { 778 return getPersistence() 779 .findByParentCategoryId(parentCategoryId, start, end, 780 orderByComparator); 781 } 782 783 /** 784 * Returns an ordered range of all the asset categories where parentCategoryId = ?. 785 * 786 * <p> 787 * 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. 788 * </p> 789 * 790 * @param parentCategoryId the parent category ID 791 * @param start the lower bound of the range of asset categories 792 * @param end the upper bound of the range of asset categories (not inclusive) 793 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 794 * @param retrieveFromCache whether to retrieve from the finder cache 795 * @return the ordered range of matching asset categories 796 */ 797 public static List<AssetCategory> findByParentCategoryId( 798 long parentCategoryId, int start, int end, 799 OrderByComparator<AssetCategory> orderByComparator, 800 boolean retrieveFromCache) { 801 return getPersistence() 802 .findByParentCategoryId(parentCategoryId, start, end, 803 orderByComparator, retrieveFromCache); 804 } 805 806 /** 807 * Returns the first asset category in the ordered set where parentCategoryId = ?. 808 * 809 * @param parentCategoryId the parent category ID 810 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 811 * @return the first matching asset category 812 * @throws NoSuchCategoryException if a matching asset category could not be found 813 */ 814 public static AssetCategory findByParentCategoryId_First( 815 long parentCategoryId, 816 OrderByComparator<AssetCategory> orderByComparator) 817 throws com.liferay.portlet.asset.NoSuchCategoryException { 818 return getPersistence() 819 .findByParentCategoryId_First(parentCategoryId, 820 orderByComparator); 821 } 822 823 /** 824 * Returns the first asset category in the ordered set where parentCategoryId = ?. 825 * 826 * @param parentCategoryId the parent category ID 827 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 828 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 829 */ 830 public static AssetCategory fetchByParentCategoryId_First( 831 long parentCategoryId, 832 OrderByComparator<AssetCategory> orderByComparator) { 833 return getPersistence() 834 .fetchByParentCategoryId_First(parentCategoryId, 835 orderByComparator); 836 } 837 838 /** 839 * Returns the last asset category in the ordered set where parentCategoryId = ?. 840 * 841 * @param parentCategoryId the parent category ID 842 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 843 * @return the last matching asset category 844 * @throws NoSuchCategoryException if a matching asset category could not be found 845 */ 846 public static AssetCategory findByParentCategoryId_Last( 847 long parentCategoryId, 848 OrderByComparator<AssetCategory> orderByComparator) 849 throws com.liferay.portlet.asset.NoSuchCategoryException { 850 return getPersistence() 851 .findByParentCategoryId_Last(parentCategoryId, 852 orderByComparator); 853 } 854 855 /** 856 * Returns the last asset category in the ordered set where parentCategoryId = ?. 857 * 858 * @param parentCategoryId the parent category ID 859 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 860 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 861 */ 862 public static AssetCategory fetchByParentCategoryId_Last( 863 long parentCategoryId, 864 OrderByComparator<AssetCategory> orderByComparator) { 865 return getPersistence() 866 .fetchByParentCategoryId_Last(parentCategoryId, 867 orderByComparator); 868 } 869 870 /** 871 * Returns the asset categories before and after the current asset category in the ordered set where parentCategoryId = ?. 872 * 873 * @param categoryId the primary key of the current asset category 874 * @param parentCategoryId the parent category ID 875 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 876 * @return the previous, current, and next asset category 877 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 878 */ 879 public static AssetCategory[] findByParentCategoryId_PrevAndNext( 880 long categoryId, long parentCategoryId, 881 OrderByComparator<AssetCategory> orderByComparator) 882 throws com.liferay.portlet.asset.NoSuchCategoryException { 883 return getPersistence() 884 .findByParentCategoryId_PrevAndNext(categoryId, 885 parentCategoryId, orderByComparator); 886 } 887 888 /** 889 * Removes all the asset categories where parentCategoryId = ? from the database. 890 * 891 * @param parentCategoryId the parent category ID 892 */ 893 public static void removeByParentCategoryId(long parentCategoryId) { 894 getPersistence().removeByParentCategoryId(parentCategoryId); 895 } 896 897 /** 898 * Returns the number of asset categories where parentCategoryId = ?. 899 * 900 * @param parentCategoryId the parent category ID 901 * @return the number of matching asset categories 902 */ 903 public static int countByParentCategoryId(long parentCategoryId) { 904 return getPersistence().countByParentCategoryId(parentCategoryId); 905 } 906 907 /** 908 * Returns all the asset categories where vocabularyId = ?. 909 * 910 * @param vocabularyId the vocabulary ID 911 * @return the matching asset categories 912 */ 913 public static List<AssetCategory> findByVocabularyId(long vocabularyId) { 914 return getPersistence().findByVocabularyId(vocabularyId); 915 } 916 917 /** 918 * Returns a range of all the asset categories where vocabularyId = ?. 919 * 920 * <p> 921 * 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. 922 * </p> 923 * 924 * @param vocabularyId the vocabulary ID 925 * @param start the lower bound of the range of asset categories 926 * @param end the upper bound of the range of asset categories (not inclusive) 927 * @return the range of matching asset categories 928 */ 929 public static List<AssetCategory> findByVocabularyId(long vocabularyId, 930 int start, int end) { 931 return getPersistence().findByVocabularyId(vocabularyId, start, end); 932 } 933 934 /** 935 * Returns an ordered range of all the asset categories where vocabularyId = ?. 936 * 937 * <p> 938 * 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. 939 * </p> 940 * 941 * @param vocabularyId the vocabulary ID 942 * @param start the lower bound of the range of asset categories 943 * @param end the upper bound of the range of asset categories (not inclusive) 944 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 945 * @return the ordered range of matching asset categories 946 */ 947 public static List<AssetCategory> findByVocabularyId(long vocabularyId, 948 int start, int end, OrderByComparator<AssetCategory> orderByComparator) { 949 return getPersistence() 950 .findByVocabularyId(vocabularyId, start, end, 951 orderByComparator); 952 } 953 954 /** 955 * Returns an ordered range of all the asset categories where vocabularyId = ?. 956 * 957 * <p> 958 * 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. 959 * </p> 960 * 961 * @param vocabularyId the vocabulary ID 962 * @param start the lower bound of the range of asset categories 963 * @param end the upper bound of the range of asset categories (not inclusive) 964 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 965 * @param retrieveFromCache whether to retrieve from the finder cache 966 * @return the ordered range of matching asset categories 967 */ 968 public static List<AssetCategory> findByVocabularyId(long vocabularyId, 969 int start, int end, OrderByComparator<AssetCategory> orderByComparator, 970 boolean retrieveFromCache) { 971 return getPersistence() 972 .findByVocabularyId(vocabularyId, start, end, 973 orderByComparator, retrieveFromCache); 974 } 975 976 /** 977 * Returns the first asset category in the ordered set where vocabularyId = ?. 978 * 979 * @param vocabularyId the vocabulary ID 980 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 981 * @return the first matching asset category 982 * @throws NoSuchCategoryException if a matching asset category could not be found 983 */ 984 public static AssetCategory findByVocabularyId_First(long vocabularyId, 985 OrderByComparator<AssetCategory> orderByComparator) 986 throws com.liferay.portlet.asset.NoSuchCategoryException { 987 return getPersistence() 988 .findByVocabularyId_First(vocabularyId, orderByComparator); 989 } 990 991 /** 992 * Returns the first asset category in the ordered set where vocabularyId = ?. 993 * 994 * @param vocabularyId the vocabulary ID 995 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 996 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 997 */ 998 public static AssetCategory fetchByVocabularyId_First(long vocabularyId, 999 OrderByComparator<AssetCategory> orderByComparator) { 1000 return getPersistence() 1001 .fetchByVocabularyId_First(vocabularyId, orderByComparator); 1002 } 1003 1004 /** 1005 * Returns the last asset category in the ordered set where vocabularyId = ?. 1006 * 1007 * @param vocabularyId the vocabulary ID 1008 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1009 * @return the last matching asset category 1010 * @throws NoSuchCategoryException if a matching asset category could not be found 1011 */ 1012 public static AssetCategory findByVocabularyId_Last(long vocabularyId, 1013 OrderByComparator<AssetCategory> orderByComparator) 1014 throws com.liferay.portlet.asset.NoSuchCategoryException { 1015 return getPersistence() 1016 .findByVocabularyId_Last(vocabularyId, orderByComparator); 1017 } 1018 1019 /** 1020 * Returns the last asset category in the ordered set where vocabularyId = ?. 1021 * 1022 * @param vocabularyId the vocabulary ID 1023 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1024 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 1025 */ 1026 public static AssetCategory fetchByVocabularyId_Last(long vocabularyId, 1027 OrderByComparator<AssetCategory> orderByComparator) { 1028 return getPersistence() 1029 .fetchByVocabularyId_Last(vocabularyId, orderByComparator); 1030 } 1031 1032 /** 1033 * Returns the asset categories before and after the current asset category in the ordered set where vocabularyId = ?. 1034 * 1035 * @param categoryId the primary key of the current asset category 1036 * @param vocabularyId the vocabulary ID 1037 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1038 * @return the previous, current, and next asset category 1039 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 1040 */ 1041 public static AssetCategory[] findByVocabularyId_PrevAndNext( 1042 long categoryId, long vocabularyId, 1043 OrderByComparator<AssetCategory> orderByComparator) 1044 throws com.liferay.portlet.asset.NoSuchCategoryException { 1045 return getPersistence() 1046 .findByVocabularyId_PrevAndNext(categoryId, vocabularyId, 1047 orderByComparator); 1048 } 1049 1050 /** 1051 * Removes all the asset categories where vocabularyId = ? from the database. 1052 * 1053 * @param vocabularyId the vocabulary ID 1054 */ 1055 public static void removeByVocabularyId(long vocabularyId) { 1056 getPersistence().removeByVocabularyId(vocabularyId); 1057 } 1058 1059 /** 1060 * Returns the number of asset categories where vocabularyId = ?. 1061 * 1062 * @param vocabularyId the vocabulary ID 1063 * @return the number of matching asset categories 1064 */ 1065 public static int countByVocabularyId(long vocabularyId) { 1066 return getPersistence().countByVocabularyId(vocabularyId); 1067 } 1068 1069 /** 1070 * Returns all the asset categories where groupId = ? and vocabularyId = ?. 1071 * 1072 * @param groupId the group ID 1073 * @param vocabularyId the vocabulary ID 1074 * @return the matching asset categories 1075 */ 1076 public static List<AssetCategory> findByG_V(long groupId, long vocabularyId) { 1077 return getPersistence().findByG_V(groupId, vocabularyId); 1078 } 1079 1080 /** 1081 * Returns a range of all the asset categories where groupId = ? and vocabularyId = ?. 1082 * 1083 * <p> 1084 * 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. 1085 * </p> 1086 * 1087 * @param groupId the group ID 1088 * @param vocabularyId the vocabulary ID 1089 * @param start the lower bound of the range of asset categories 1090 * @param end the upper bound of the range of asset categories (not inclusive) 1091 * @return the range of matching asset categories 1092 */ 1093 public static List<AssetCategory> findByG_V(long groupId, 1094 long vocabularyId, int start, int end) { 1095 return getPersistence().findByG_V(groupId, vocabularyId, start, end); 1096 } 1097 1098 /** 1099 * Returns an ordered range of all the asset categories where groupId = ? and vocabularyId = ?. 1100 * 1101 * <p> 1102 * 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. 1103 * </p> 1104 * 1105 * @param groupId the group ID 1106 * @param vocabularyId the vocabulary ID 1107 * @param start the lower bound of the range of asset categories 1108 * @param end the upper bound of the range of asset categories (not inclusive) 1109 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1110 * @return the ordered range of matching asset categories 1111 */ 1112 public static List<AssetCategory> findByG_V(long groupId, 1113 long vocabularyId, int start, int end, 1114 OrderByComparator<AssetCategory> orderByComparator) { 1115 return getPersistence() 1116 .findByG_V(groupId, vocabularyId, start, end, 1117 orderByComparator); 1118 } 1119 1120 /** 1121 * Returns an ordered range of all the asset categories where groupId = ? and vocabularyId = ?. 1122 * 1123 * <p> 1124 * 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. 1125 * </p> 1126 * 1127 * @param groupId the group ID 1128 * @param vocabularyId the vocabulary ID 1129 * @param start the lower bound of the range of asset categories 1130 * @param end the upper bound of the range of asset categories (not inclusive) 1131 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1132 * @param retrieveFromCache whether to retrieve from the finder cache 1133 * @return the ordered range of matching asset categories 1134 */ 1135 public static List<AssetCategory> findByG_V(long groupId, 1136 long vocabularyId, int start, int end, 1137 OrderByComparator<AssetCategory> orderByComparator, 1138 boolean retrieveFromCache) { 1139 return getPersistence() 1140 .findByG_V(groupId, vocabularyId, start, end, 1141 orderByComparator, retrieveFromCache); 1142 } 1143 1144 /** 1145 * Returns the first asset category in the ordered set where groupId = ? and vocabularyId = ?. 1146 * 1147 * @param groupId the group ID 1148 * @param vocabularyId the vocabulary ID 1149 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1150 * @return the first matching asset category 1151 * @throws NoSuchCategoryException if a matching asset category could not be found 1152 */ 1153 public static AssetCategory findByG_V_First(long groupId, 1154 long vocabularyId, OrderByComparator<AssetCategory> orderByComparator) 1155 throws com.liferay.portlet.asset.NoSuchCategoryException { 1156 return getPersistence() 1157 .findByG_V_First(groupId, vocabularyId, orderByComparator); 1158 } 1159 1160 /** 1161 * Returns the first asset category in the ordered set where groupId = ? and vocabularyId = ?. 1162 * 1163 * @param groupId the group ID 1164 * @param vocabularyId the vocabulary ID 1165 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1166 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 1167 */ 1168 public static AssetCategory fetchByG_V_First(long groupId, 1169 long vocabularyId, OrderByComparator<AssetCategory> orderByComparator) { 1170 return getPersistence() 1171 .fetchByG_V_First(groupId, vocabularyId, orderByComparator); 1172 } 1173 1174 /** 1175 * Returns the last asset category in the ordered set where groupId = ? and vocabularyId = ?. 1176 * 1177 * @param groupId the group ID 1178 * @param vocabularyId the vocabulary ID 1179 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1180 * @return the last matching asset category 1181 * @throws NoSuchCategoryException if a matching asset category could not be found 1182 */ 1183 public static AssetCategory findByG_V_Last(long groupId, long vocabularyId, 1184 OrderByComparator<AssetCategory> orderByComparator) 1185 throws com.liferay.portlet.asset.NoSuchCategoryException { 1186 return getPersistence() 1187 .findByG_V_Last(groupId, vocabularyId, orderByComparator); 1188 } 1189 1190 /** 1191 * Returns the last asset category in the ordered set where groupId = ? and vocabularyId = ?. 1192 * 1193 * @param groupId the group ID 1194 * @param vocabularyId the vocabulary ID 1195 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1196 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 1197 */ 1198 public static AssetCategory fetchByG_V_Last(long groupId, 1199 long vocabularyId, OrderByComparator<AssetCategory> orderByComparator) { 1200 return getPersistence() 1201 .fetchByG_V_Last(groupId, vocabularyId, orderByComparator); 1202 } 1203 1204 /** 1205 * Returns the asset categories before and after the current asset category in the ordered set where groupId = ? and vocabularyId = ?. 1206 * 1207 * @param categoryId the primary key of the current asset category 1208 * @param groupId the group ID 1209 * @param vocabularyId the vocabulary ID 1210 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1211 * @return the previous, current, and next asset category 1212 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 1213 */ 1214 public static AssetCategory[] findByG_V_PrevAndNext(long categoryId, 1215 long groupId, long vocabularyId, 1216 OrderByComparator<AssetCategory> orderByComparator) 1217 throws com.liferay.portlet.asset.NoSuchCategoryException { 1218 return getPersistence() 1219 .findByG_V_PrevAndNext(categoryId, groupId, vocabularyId, 1220 orderByComparator); 1221 } 1222 1223 /** 1224 * Returns all the asset categories that the user has permission to view where groupId = ? and vocabularyId = ?. 1225 * 1226 * @param groupId the group ID 1227 * @param vocabularyId the vocabulary ID 1228 * @return the matching asset categories that the user has permission to view 1229 */ 1230 public static List<AssetCategory> filterFindByG_V(long groupId, 1231 long vocabularyId) { 1232 return getPersistence().filterFindByG_V(groupId, vocabularyId); 1233 } 1234 1235 /** 1236 * Returns a range of all the asset categories that the user has permission to view where groupId = ? and vocabularyId = ?. 1237 * 1238 * <p> 1239 * 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. 1240 * </p> 1241 * 1242 * @param groupId the group ID 1243 * @param vocabularyId the vocabulary ID 1244 * @param start the lower bound of the range of asset categories 1245 * @param end the upper bound of the range of asset categories (not inclusive) 1246 * @return the range of matching asset categories that the user has permission to view 1247 */ 1248 public static List<AssetCategory> filterFindByG_V(long groupId, 1249 long vocabularyId, int start, int end) { 1250 return getPersistence() 1251 .filterFindByG_V(groupId, vocabularyId, start, end); 1252 } 1253 1254 /** 1255 * Returns an ordered range of all the asset categories that the user has permissions to view where groupId = ? and vocabularyId = ?. 1256 * 1257 * <p> 1258 * 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. 1259 * </p> 1260 * 1261 * @param groupId the group ID 1262 * @param vocabularyId the vocabulary ID 1263 * @param start the lower bound of the range of asset categories 1264 * @param end the upper bound of the range of asset categories (not inclusive) 1265 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1266 * @return the ordered range of matching asset categories that the user has permission to view 1267 */ 1268 public static List<AssetCategory> filterFindByG_V(long groupId, 1269 long vocabularyId, int start, int end, 1270 OrderByComparator<AssetCategory> orderByComparator) { 1271 return getPersistence() 1272 .filterFindByG_V(groupId, vocabularyId, start, end, 1273 orderByComparator); 1274 } 1275 1276 /** 1277 * 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 = ?. 1278 * 1279 * @param categoryId the primary key of the current asset category 1280 * @param groupId the group ID 1281 * @param vocabularyId the vocabulary ID 1282 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1283 * @return the previous, current, and next asset category 1284 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 1285 */ 1286 public static AssetCategory[] filterFindByG_V_PrevAndNext(long categoryId, 1287 long groupId, long vocabularyId, 1288 OrderByComparator<AssetCategory> orderByComparator) 1289 throws com.liferay.portlet.asset.NoSuchCategoryException { 1290 return getPersistence() 1291 .filterFindByG_V_PrevAndNext(categoryId, groupId, 1292 vocabularyId, orderByComparator); 1293 } 1294 1295 /** 1296 * Returns all the asset categories that the user has permission to view where groupId = ? and vocabularyId = any ?. 1297 * 1298 * @param groupId the group ID 1299 * @param vocabularyIds the vocabulary IDs 1300 * @return the matching asset categories that the user has permission to view 1301 */ 1302 public static List<AssetCategory> filterFindByG_V(long groupId, 1303 long[] vocabularyIds) { 1304 return getPersistence().filterFindByG_V(groupId, vocabularyIds); 1305 } 1306 1307 /** 1308 * Returns a range of all the asset categories that the user has permission to view where groupId = ? and vocabularyId = any ?. 1309 * 1310 * <p> 1311 * 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. 1312 * </p> 1313 * 1314 * @param groupId the group ID 1315 * @param vocabularyIds the vocabulary IDs 1316 * @param start the lower bound of the range of asset categories 1317 * @param end the upper bound of the range of asset categories (not inclusive) 1318 * @return the range of matching asset categories that the user has permission to view 1319 */ 1320 public static List<AssetCategory> filterFindByG_V(long groupId, 1321 long[] vocabularyIds, int start, int end) { 1322 return getPersistence() 1323 .filterFindByG_V(groupId, vocabularyIds, start, end); 1324 } 1325 1326 /** 1327 * Returns an ordered range of all the asset categories that the user has permission to view where groupId = ? and vocabularyId = any ?. 1328 * 1329 * <p> 1330 * 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. 1331 * </p> 1332 * 1333 * @param groupId the group ID 1334 * @param vocabularyIds the vocabulary IDs 1335 * @param start the lower bound of the range of asset categories 1336 * @param end the upper bound of the range of asset categories (not inclusive) 1337 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1338 * @return the ordered range of matching asset categories that the user has permission to view 1339 */ 1340 public static List<AssetCategory> filterFindByG_V(long groupId, 1341 long[] vocabularyIds, int start, int end, 1342 OrderByComparator<AssetCategory> orderByComparator) { 1343 return getPersistence() 1344 .filterFindByG_V(groupId, vocabularyIds, start, end, 1345 orderByComparator); 1346 } 1347 1348 /** 1349 * Returns all the asset categories where groupId = ? and vocabularyId = any ?. 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 groupId the group ID 1356 * @param vocabularyIds the vocabulary IDs 1357 * @return the matching asset categories 1358 */ 1359 public static List<AssetCategory> findByG_V(long groupId, 1360 long[] vocabularyIds) { 1361 return getPersistence().findByG_V(groupId, vocabularyIds); 1362 } 1363 1364 /** 1365 * Returns a range of all the asset categories where groupId = ? and vocabularyId = any ?. 1366 * 1367 * <p> 1368 * 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. 1369 * </p> 1370 * 1371 * @param groupId the group ID 1372 * @param vocabularyIds the vocabulary IDs 1373 * @param start the lower bound of the range of asset categories 1374 * @param end the upper bound of the range of asset categories (not inclusive) 1375 * @return the range of matching asset categories 1376 */ 1377 public static List<AssetCategory> findByG_V(long groupId, 1378 long[] vocabularyIds, int start, int end) { 1379 return getPersistence().findByG_V(groupId, vocabularyIds, start, end); 1380 } 1381 1382 /** 1383 * Returns an ordered range of all the asset categories where groupId = ? and vocabularyId = any ?. 1384 * 1385 * <p> 1386 * 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. 1387 * </p> 1388 * 1389 * @param groupId the group ID 1390 * @param vocabularyIds the vocabulary IDs 1391 * @param start the lower bound of the range of asset categories 1392 * @param end the upper bound of the range of asset categories (not inclusive) 1393 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1394 * @return the ordered range of matching asset categories 1395 */ 1396 public static List<AssetCategory> findByG_V(long groupId, 1397 long[] vocabularyIds, int start, int end, 1398 OrderByComparator<AssetCategory> orderByComparator) { 1399 return getPersistence() 1400 .findByG_V(groupId, vocabularyIds, start, end, 1401 orderByComparator); 1402 } 1403 1404 /** 1405 * Returns an ordered range of all the asset categories where groupId = ? and vocabularyId = ?, optionally using the finder cache. 1406 * 1407 * <p> 1408 * 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. 1409 * </p> 1410 * 1411 * @param groupId the group ID 1412 * @param vocabularyId the vocabulary ID 1413 * @param start the lower bound of the range of asset categories 1414 * @param end the upper bound of the range of asset categories (not inclusive) 1415 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1416 * @param retrieveFromCache whether to retrieve from the finder cache 1417 * @return the ordered range of matching asset categories 1418 */ 1419 public static List<AssetCategory> findByG_V(long groupId, 1420 long[] vocabularyIds, int start, int end, 1421 OrderByComparator<AssetCategory> orderByComparator, 1422 boolean retrieveFromCache) { 1423 return getPersistence() 1424 .findByG_V(groupId, vocabularyIds, start, end, 1425 orderByComparator, retrieveFromCache); 1426 } 1427 1428 /** 1429 * Removes all the asset categories where groupId = ? and vocabularyId = ? from the database. 1430 * 1431 * @param groupId the group ID 1432 * @param vocabularyId the vocabulary ID 1433 */ 1434 public static void removeByG_V(long groupId, long vocabularyId) { 1435 getPersistence().removeByG_V(groupId, vocabularyId); 1436 } 1437 1438 /** 1439 * Returns the number of asset categories where groupId = ? and vocabularyId = ?. 1440 * 1441 * @param groupId the group ID 1442 * @param vocabularyId the vocabulary ID 1443 * @return the number of matching asset categories 1444 */ 1445 public static int countByG_V(long groupId, long vocabularyId) { 1446 return getPersistence().countByG_V(groupId, vocabularyId); 1447 } 1448 1449 /** 1450 * Returns the number of asset categories where groupId = ? and vocabularyId = any ?. 1451 * 1452 * @param groupId the group ID 1453 * @param vocabularyIds the vocabulary IDs 1454 * @return the number of matching asset categories 1455 */ 1456 public static int countByG_V(long groupId, long[] vocabularyIds) { 1457 return getPersistence().countByG_V(groupId, vocabularyIds); 1458 } 1459 1460 /** 1461 * Returns the number of asset categories that the user has permission to view where groupId = ? and vocabularyId = ?. 1462 * 1463 * @param groupId the group ID 1464 * @param vocabularyId the vocabulary ID 1465 * @return the number of matching asset categories that the user has permission to view 1466 */ 1467 public static int filterCountByG_V(long groupId, long vocabularyId) { 1468 return getPersistence().filterCountByG_V(groupId, vocabularyId); 1469 } 1470 1471 /** 1472 * Returns the number of asset categories that the user has permission to view where groupId = ? and vocabularyId = any ?. 1473 * 1474 * @param groupId the group ID 1475 * @param vocabularyIds the vocabulary IDs 1476 * @return the number of matching asset categories that the user has permission to view 1477 */ 1478 public static int filterCountByG_V(long groupId, long[] vocabularyIds) { 1479 return getPersistence().filterCountByG_V(groupId, vocabularyIds); 1480 } 1481 1482 /** 1483 * Returns all the asset categories where parentCategoryId = ? and name = ?. 1484 * 1485 * @param parentCategoryId the parent category ID 1486 * @param name the name 1487 * @return the matching asset categories 1488 */ 1489 public static List<AssetCategory> findByP_N(long parentCategoryId, 1490 java.lang.String name) { 1491 return getPersistence().findByP_N(parentCategoryId, name); 1492 } 1493 1494 /** 1495 * Returns a range of all the asset categories where parentCategoryId = ? and name = ?. 1496 * 1497 * <p> 1498 * 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. 1499 * </p> 1500 * 1501 * @param parentCategoryId the parent category ID 1502 * @param name the name 1503 * @param start the lower bound of the range of asset categories 1504 * @param end the upper bound of the range of asset categories (not inclusive) 1505 * @return the range of matching asset categories 1506 */ 1507 public static List<AssetCategory> findByP_N(long parentCategoryId, 1508 java.lang.String name, int start, int end) { 1509 return getPersistence().findByP_N(parentCategoryId, name, start, end); 1510 } 1511 1512 /** 1513 * Returns an ordered range of all the asset categories where parentCategoryId = ? and name = ?. 1514 * 1515 * <p> 1516 * 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. 1517 * </p> 1518 * 1519 * @param parentCategoryId the parent category ID 1520 * @param name the name 1521 * @param start the lower bound of the range of asset categories 1522 * @param end the upper bound of the range of asset categories (not inclusive) 1523 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1524 * @return the ordered range of matching asset categories 1525 */ 1526 public static List<AssetCategory> findByP_N(long parentCategoryId, 1527 java.lang.String name, int start, int end, 1528 OrderByComparator<AssetCategory> orderByComparator) { 1529 return getPersistence() 1530 .findByP_N(parentCategoryId, name, start, end, 1531 orderByComparator); 1532 } 1533 1534 /** 1535 * Returns an ordered range of all the asset categories where parentCategoryId = ? and name = ?. 1536 * 1537 * <p> 1538 * 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. 1539 * </p> 1540 * 1541 * @param parentCategoryId the parent category ID 1542 * @param name the name 1543 * @param start the lower bound of the range of asset categories 1544 * @param end the upper bound of the range of asset categories (not inclusive) 1545 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1546 * @param retrieveFromCache whether to retrieve from the finder cache 1547 * @return the ordered range of matching asset categories 1548 */ 1549 public static List<AssetCategory> findByP_N(long parentCategoryId, 1550 java.lang.String name, int start, int end, 1551 OrderByComparator<AssetCategory> orderByComparator, 1552 boolean retrieveFromCache) { 1553 return getPersistence() 1554 .findByP_N(parentCategoryId, name, start, end, 1555 orderByComparator, retrieveFromCache); 1556 } 1557 1558 /** 1559 * Returns the first asset category in the ordered set where parentCategoryId = ? and name = ?. 1560 * 1561 * @param parentCategoryId the parent category ID 1562 * @param name the name 1563 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1564 * @return the first matching asset category 1565 * @throws NoSuchCategoryException if a matching asset category could not be found 1566 */ 1567 public static AssetCategory findByP_N_First(long parentCategoryId, 1568 java.lang.String name, 1569 OrderByComparator<AssetCategory> orderByComparator) 1570 throws com.liferay.portlet.asset.NoSuchCategoryException { 1571 return getPersistence() 1572 .findByP_N_First(parentCategoryId, name, orderByComparator); 1573 } 1574 1575 /** 1576 * Returns the first asset category in the ordered set where parentCategoryId = ? and name = ?. 1577 * 1578 * @param parentCategoryId the parent category ID 1579 * @param name the name 1580 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1581 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 1582 */ 1583 public static AssetCategory fetchByP_N_First(long parentCategoryId, 1584 java.lang.String name, 1585 OrderByComparator<AssetCategory> orderByComparator) { 1586 return getPersistence() 1587 .fetchByP_N_First(parentCategoryId, name, orderByComparator); 1588 } 1589 1590 /** 1591 * Returns the last asset category in the ordered set where parentCategoryId = ? and name = ?. 1592 * 1593 * @param parentCategoryId the parent category ID 1594 * @param name the name 1595 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1596 * @return the last matching asset category 1597 * @throws NoSuchCategoryException if a matching asset category could not be found 1598 */ 1599 public static AssetCategory findByP_N_Last(long parentCategoryId, 1600 java.lang.String name, 1601 OrderByComparator<AssetCategory> orderByComparator) 1602 throws com.liferay.portlet.asset.NoSuchCategoryException { 1603 return getPersistence() 1604 .findByP_N_Last(parentCategoryId, name, orderByComparator); 1605 } 1606 1607 /** 1608 * Returns the last asset category in the ordered set where parentCategoryId = ? and name = ?. 1609 * 1610 * @param parentCategoryId the parent category ID 1611 * @param name the name 1612 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1613 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 1614 */ 1615 public static AssetCategory fetchByP_N_Last(long parentCategoryId, 1616 java.lang.String name, 1617 OrderByComparator<AssetCategory> orderByComparator) { 1618 return getPersistence() 1619 .fetchByP_N_Last(parentCategoryId, name, orderByComparator); 1620 } 1621 1622 /** 1623 * Returns the asset categories before and after the current asset category in the ordered set where parentCategoryId = ? and name = ?. 1624 * 1625 * @param categoryId the primary key of the current asset category 1626 * @param parentCategoryId the parent category ID 1627 * @param name the name 1628 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1629 * @return the previous, current, and next asset category 1630 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 1631 */ 1632 public static AssetCategory[] findByP_N_PrevAndNext(long categoryId, 1633 long parentCategoryId, java.lang.String name, 1634 OrderByComparator<AssetCategory> orderByComparator) 1635 throws com.liferay.portlet.asset.NoSuchCategoryException { 1636 return getPersistence() 1637 .findByP_N_PrevAndNext(categoryId, parentCategoryId, name, 1638 orderByComparator); 1639 } 1640 1641 /** 1642 * Removes all the asset categories where parentCategoryId = ? and name = ? from the database. 1643 * 1644 * @param parentCategoryId the parent category ID 1645 * @param name the name 1646 */ 1647 public static void removeByP_N(long parentCategoryId, java.lang.String name) { 1648 getPersistence().removeByP_N(parentCategoryId, name); 1649 } 1650 1651 /** 1652 * Returns the number of asset categories where parentCategoryId = ? and name = ?. 1653 * 1654 * @param parentCategoryId the parent category ID 1655 * @param name the name 1656 * @return the number of matching asset categories 1657 */ 1658 public static int countByP_N(long parentCategoryId, java.lang.String name) { 1659 return getPersistence().countByP_N(parentCategoryId, name); 1660 } 1661 1662 /** 1663 * Returns all the asset categories where parentCategoryId = ? and vocabularyId = ?. 1664 * 1665 * @param parentCategoryId the parent category ID 1666 * @param vocabularyId the vocabulary ID 1667 * @return the matching asset categories 1668 */ 1669 public static List<AssetCategory> findByP_V(long parentCategoryId, 1670 long vocabularyId) { 1671 return getPersistence().findByP_V(parentCategoryId, vocabularyId); 1672 } 1673 1674 /** 1675 * Returns a range of all the asset categories where parentCategoryId = ? and vocabularyId = ?. 1676 * 1677 * <p> 1678 * 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. 1679 * </p> 1680 * 1681 * @param parentCategoryId the parent category ID 1682 * @param vocabularyId the vocabulary ID 1683 * @param start the lower bound of the range of asset categories 1684 * @param end the upper bound of the range of asset categories (not inclusive) 1685 * @return the range of matching asset categories 1686 */ 1687 public static List<AssetCategory> findByP_V(long parentCategoryId, 1688 long vocabularyId, int start, int end) { 1689 return getPersistence() 1690 .findByP_V(parentCategoryId, vocabularyId, start, end); 1691 } 1692 1693 /** 1694 * Returns an ordered range of all the asset categories where parentCategoryId = ? and vocabularyId = ?. 1695 * 1696 * <p> 1697 * 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. 1698 * </p> 1699 * 1700 * @param parentCategoryId the parent category ID 1701 * @param vocabularyId the vocabulary ID 1702 * @param start the lower bound of the range of asset categories 1703 * @param end the upper bound of the range of asset categories (not inclusive) 1704 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1705 * @return the ordered range of matching asset categories 1706 */ 1707 public static List<AssetCategory> findByP_V(long parentCategoryId, 1708 long vocabularyId, int start, int end, 1709 OrderByComparator<AssetCategory> orderByComparator) { 1710 return getPersistence() 1711 .findByP_V(parentCategoryId, vocabularyId, start, end, 1712 orderByComparator); 1713 } 1714 1715 /** 1716 * Returns an ordered range of all the asset categories where parentCategoryId = ? and vocabularyId = ?. 1717 * 1718 * <p> 1719 * 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. 1720 * </p> 1721 * 1722 * @param parentCategoryId the parent category ID 1723 * @param vocabularyId the vocabulary ID 1724 * @param start the lower bound of the range of asset categories 1725 * @param end the upper bound of the range of asset categories (not inclusive) 1726 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1727 * @param retrieveFromCache whether to retrieve from the finder cache 1728 * @return the ordered range of matching asset categories 1729 */ 1730 public static List<AssetCategory> findByP_V(long parentCategoryId, 1731 long vocabularyId, int start, int end, 1732 OrderByComparator<AssetCategory> orderByComparator, 1733 boolean retrieveFromCache) { 1734 return getPersistence() 1735 .findByP_V(parentCategoryId, vocabularyId, start, end, 1736 orderByComparator, retrieveFromCache); 1737 } 1738 1739 /** 1740 * Returns the first asset category in the ordered set where parentCategoryId = ? and vocabularyId = ?. 1741 * 1742 * @param parentCategoryId the parent category ID 1743 * @param vocabularyId the vocabulary ID 1744 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1745 * @return the first matching asset category 1746 * @throws NoSuchCategoryException if a matching asset category could not be found 1747 */ 1748 public static AssetCategory findByP_V_First(long parentCategoryId, 1749 long vocabularyId, OrderByComparator<AssetCategory> orderByComparator) 1750 throws com.liferay.portlet.asset.NoSuchCategoryException { 1751 return getPersistence() 1752 .findByP_V_First(parentCategoryId, vocabularyId, 1753 orderByComparator); 1754 } 1755 1756 /** 1757 * Returns the first asset category in the ordered set where parentCategoryId = ? and vocabularyId = ?. 1758 * 1759 * @param parentCategoryId the parent category ID 1760 * @param vocabularyId the vocabulary ID 1761 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1762 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 1763 */ 1764 public static AssetCategory fetchByP_V_First(long parentCategoryId, 1765 long vocabularyId, OrderByComparator<AssetCategory> orderByComparator) { 1766 return getPersistence() 1767 .fetchByP_V_First(parentCategoryId, vocabularyId, 1768 orderByComparator); 1769 } 1770 1771 /** 1772 * Returns the last asset category in the ordered set where parentCategoryId = ? and vocabularyId = ?. 1773 * 1774 * @param parentCategoryId the parent category ID 1775 * @param vocabularyId the vocabulary ID 1776 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1777 * @return the last matching asset category 1778 * @throws NoSuchCategoryException if a matching asset category could not be found 1779 */ 1780 public static AssetCategory findByP_V_Last(long parentCategoryId, 1781 long vocabularyId, OrderByComparator<AssetCategory> orderByComparator) 1782 throws com.liferay.portlet.asset.NoSuchCategoryException { 1783 return getPersistence() 1784 .findByP_V_Last(parentCategoryId, vocabularyId, 1785 orderByComparator); 1786 } 1787 1788 /** 1789 * Returns the last asset category in the ordered set where parentCategoryId = ? and vocabularyId = ?. 1790 * 1791 * @param parentCategoryId the parent category ID 1792 * @param vocabularyId the vocabulary ID 1793 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1794 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 1795 */ 1796 public static AssetCategory fetchByP_V_Last(long parentCategoryId, 1797 long vocabularyId, OrderByComparator<AssetCategory> orderByComparator) { 1798 return getPersistence() 1799 .fetchByP_V_Last(parentCategoryId, vocabularyId, 1800 orderByComparator); 1801 } 1802 1803 /** 1804 * Returns the asset categories before and after the current asset category in the ordered set where parentCategoryId = ? and vocabularyId = ?. 1805 * 1806 * @param categoryId the primary key of the current asset category 1807 * @param parentCategoryId the parent category ID 1808 * @param vocabularyId the vocabulary ID 1809 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1810 * @return the previous, current, and next asset category 1811 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 1812 */ 1813 public static AssetCategory[] findByP_V_PrevAndNext(long categoryId, 1814 long parentCategoryId, long vocabularyId, 1815 OrderByComparator<AssetCategory> orderByComparator) 1816 throws com.liferay.portlet.asset.NoSuchCategoryException { 1817 return getPersistence() 1818 .findByP_V_PrevAndNext(categoryId, parentCategoryId, 1819 vocabularyId, orderByComparator); 1820 } 1821 1822 /** 1823 * Removes all the asset categories where parentCategoryId = ? and vocabularyId = ? from the database. 1824 * 1825 * @param parentCategoryId the parent category ID 1826 * @param vocabularyId the vocabulary ID 1827 */ 1828 public static void removeByP_V(long parentCategoryId, long vocabularyId) { 1829 getPersistence().removeByP_V(parentCategoryId, vocabularyId); 1830 } 1831 1832 /** 1833 * Returns the number of asset categories where parentCategoryId = ? and vocabularyId = ?. 1834 * 1835 * @param parentCategoryId the parent category ID 1836 * @param vocabularyId the vocabulary ID 1837 * @return the number of matching asset categories 1838 */ 1839 public static int countByP_V(long parentCategoryId, long vocabularyId) { 1840 return getPersistence().countByP_V(parentCategoryId, vocabularyId); 1841 } 1842 1843 /** 1844 * Returns all the asset categories where name = ? and vocabularyId = ?. 1845 * 1846 * @param name the name 1847 * @param vocabularyId the vocabulary ID 1848 * @return the matching asset categories 1849 */ 1850 public static List<AssetCategory> findByN_V(java.lang.String name, 1851 long vocabularyId) { 1852 return getPersistence().findByN_V(name, vocabularyId); 1853 } 1854 1855 /** 1856 * Returns a range of all the asset categories where name = ? and vocabularyId = ?. 1857 * 1858 * <p> 1859 * 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. 1860 * </p> 1861 * 1862 * @param name the name 1863 * @param vocabularyId the vocabulary ID 1864 * @param start the lower bound of the range of asset categories 1865 * @param end the upper bound of the range of asset categories (not inclusive) 1866 * @return the range of matching asset categories 1867 */ 1868 public static List<AssetCategory> findByN_V(java.lang.String name, 1869 long vocabularyId, int start, int end) { 1870 return getPersistence().findByN_V(name, vocabularyId, start, end); 1871 } 1872 1873 /** 1874 * Returns an ordered range of all the asset categories where name = ? and vocabularyId = ?. 1875 * 1876 * <p> 1877 * 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. 1878 * </p> 1879 * 1880 * @param name the name 1881 * @param vocabularyId the vocabulary ID 1882 * @param start the lower bound of the range of asset categories 1883 * @param end the upper bound of the range of asset categories (not inclusive) 1884 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1885 * @return the ordered range of matching asset categories 1886 */ 1887 public static List<AssetCategory> findByN_V(java.lang.String name, 1888 long vocabularyId, int start, int end, 1889 OrderByComparator<AssetCategory> orderByComparator) { 1890 return getPersistence() 1891 .findByN_V(name, vocabularyId, start, end, orderByComparator); 1892 } 1893 1894 /** 1895 * Returns an ordered range of all the asset categories where name = ? and vocabularyId = ?. 1896 * 1897 * <p> 1898 * 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. 1899 * </p> 1900 * 1901 * @param name the name 1902 * @param vocabularyId the vocabulary ID 1903 * @param start the lower bound of the range of asset categories 1904 * @param end the upper bound of the range of asset categories (not inclusive) 1905 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1906 * @param retrieveFromCache whether to retrieve from the finder cache 1907 * @return the ordered range of matching asset categories 1908 */ 1909 public static List<AssetCategory> findByN_V(java.lang.String name, 1910 long vocabularyId, int start, int end, 1911 OrderByComparator<AssetCategory> orderByComparator, 1912 boolean retrieveFromCache) { 1913 return getPersistence() 1914 .findByN_V(name, vocabularyId, start, end, 1915 orderByComparator, retrieveFromCache); 1916 } 1917 1918 /** 1919 * Returns the first asset category in the ordered set where name = ? and vocabularyId = ?. 1920 * 1921 * @param name the name 1922 * @param vocabularyId the vocabulary ID 1923 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1924 * @return the first matching asset category 1925 * @throws NoSuchCategoryException if a matching asset category could not be found 1926 */ 1927 public static AssetCategory findByN_V_First(java.lang.String name, 1928 long vocabularyId, OrderByComparator<AssetCategory> orderByComparator) 1929 throws com.liferay.portlet.asset.NoSuchCategoryException { 1930 return getPersistence() 1931 .findByN_V_First(name, vocabularyId, orderByComparator); 1932 } 1933 1934 /** 1935 * Returns the first asset category in the ordered set where name = ? and vocabularyId = ?. 1936 * 1937 * @param name the name 1938 * @param vocabularyId the vocabulary ID 1939 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1940 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 1941 */ 1942 public static AssetCategory fetchByN_V_First(java.lang.String name, 1943 long vocabularyId, OrderByComparator<AssetCategory> orderByComparator) { 1944 return getPersistence() 1945 .fetchByN_V_First(name, vocabularyId, orderByComparator); 1946 } 1947 1948 /** 1949 * Returns the last asset category in the ordered set where name = ? and vocabularyId = ?. 1950 * 1951 * @param name the name 1952 * @param vocabularyId the vocabulary ID 1953 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1954 * @return the last matching asset category 1955 * @throws NoSuchCategoryException if a matching asset category could not be found 1956 */ 1957 public static AssetCategory findByN_V_Last(java.lang.String name, 1958 long vocabularyId, OrderByComparator<AssetCategory> orderByComparator) 1959 throws com.liferay.portlet.asset.NoSuchCategoryException { 1960 return getPersistence() 1961 .findByN_V_Last(name, vocabularyId, orderByComparator); 1962 } 1963 1964 /** 1965 * Returns the last asset category in the ordered set where name = ? and vocabularyId = ?. 1966 * 1967 * @param name the name 1968 * @param vocabularyId the vocabulary ID 1969 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1970 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 1971 */ 1972 public static AssetCategory fetchByN_V_Last(java.lang.String name, 1973 long vocabularyId, OrderByComparator<AssetCategory> orderByComparator) { 1974 return getPersistence() 1975 .fetchByN_V_Last(name, vocabularyId, orderByComparator); 1976 } 1977 1978 /** 1979 * Returns the asset categories before and after the current asset category in the ordered set where name = ? and vocabularyId = ?. 1980 * 1981 * @param categoryId the primary key of the current asset category 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 static AssetCategory[] findByN_V_PrevAndNext(long categoryId, 1989 java.lang.String name, long vocabularyId, 1990 OrderByComparator<AssetCategory> orderByComparator) 1991 throws com.liferay.portlet.asset.NoSuchCategoryException { 1992 return getPersistence() 1993 .findByN_V_PrevAndNext(categoryId, name, vocabularyId, 1994 orderByComparator); 1995 } 1996 1997 /** 1998 * Removes all the asset categories where name = ? and vocabularyId = ? from the database. 1999 * 2000 * @param name the name 2001 * @param vocabularyId the vocabulary ID 2002 */ 2003 public static void removeByN_V(java.lang.String name, long vocabularyId) { 2004 getPersistence().removeByN_V(name, vocabularyId); 2005 } 2006 2007 /** 2008 * Returns the number of asset categories where name = ? and vocabularyId = ?. 2009 * 2010 * @param name the name 2011 * @param vocabularyId the vocabulary ID 2012 * @return the number of matching asset categories 2013 */ 2014 public static int countByN_V(java.lang.String name, long vocabularyId) { 2015 return getPersistence().countByN_V(name, vocabularyId); 2016 } 2017 2018 /** 2019 * Returns all the asset categories where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 2020 * 2021 * @param groupId the group ID 2022 * @param parentCategoryId the parent category ID 2023 * @param vocabularyId the vocabulary ID 2024 * @return the matching asset categories 2025 */ 2026 public static List<AssetCategory> findByG_P_V(long groupId, 2027 long parentCategoryId, long vocabularyId) { 2028 return getPersistence() 2029 .findByG_P_V(groupId, parentCategoryId, vocabularyId); 2030 } 2031 2032 /** 2033 * Returns a range of all the asset categories where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 2034 * 2035 * <p> 2036 * 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. 2037 * </p> 2038 * 2039 * @param groupId the group ID 2040 * @param parentCategoryId the parent category ID 2041 * @param vocabularyId the vocabulary ID 2042 * @param start the lower bound of the range of asset categories 2043 * @param end the upper bound of the range of asset categories (not inclusive) 2044 * @return the range of matching asset categories 2045 */ 2046 public static List<AssetCategory> findByG_P_V(long groupId, 2047 long parentCategoryId, long vocabularyId, int start, int end) { 2048 return getPersistence() 2049 .findByG_P_V(groupId, parentCategoryId, vocabularyId, start, 2050 end); 2051 } 2052 2053 /** 2054 * Returns an ordered range of all the asset categories where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 2055 * 2056 * <p> 2057 * 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. 2058 * </p> 2059 * 2060 * @param groupId the group ID 2061 * @param parentCategoryId the parent category ID 2062 * @param vocabularyId the vocabulary ID 2063 * @param start the lower bound of the range of asset categories 2064 * @param end the upper bound of the range of asset categories (not inclusive) 2065 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2066 * @return the ordered range of matching asset categories 2067 */ 2068 public static List<AssetCategory> findByG_P_V(long groupId, 2069 long parentCategoryId, long vocabularyId, int start, int end, 2070 OrderByComparator<AssetCategory> orderByComparator) { 2071 return getPersistence() 2072 .findByG_P_V(groupId, parentCategoryId, vocabularyId, start, 2073 end, orderByComparator); 2074 } 2075 2076 /** 2077 * Returns an ordered range of all the asset categories where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 2078 * 2079 * <p> 2080 * 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. 2081 * </p> 2082 * 2083 * @param groupId the group ID 2084 * @param parentCategoryId the parent category ID 2085 * @param vocabularyId the vocabulary ID 2086 * @param start the lower bound of the range of asset categories 2087 * @param end the upper bound of the range of asset categories (not inclusive) 2088 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2089 * @param retrieveFromCache whether to retrieve from the finder cache 2090 * @return the ordered range of matching asset categories 2091 */ 2092 public static List<AssetCategory> findByG_P_V(long groupId, 2093 long parentCategoryId, long vocabularyId, int start, int end, 2094 OrderByComparator<AssetCategory> orderByComparator, 2095 boolean retrieveFromCache) { 2096 return getPersistence() 2097 .findByG_P_V(groupId, parentCategoryId, vocabularyId, start, 2098 end, orderByComparator, retrieveFromCache); 2099 } 2100 2101 /** 2102 * Returns the first asset category in the ordered set where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 2103 * 2104 * @param groupId the group ID 2105 * @param parentCategoryId the parent category ID 2106 * @param vocabularyId the vocabulary ID 2107 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2108 * @return the first matching asset category 2109 * @throws NoSuchCategoryException if a matching asset category could not be found 2110 */ 2111 public static AssetCategory findByG_P_V_First(long groupId, 2112 long parentCategoryId, long vocabularyId, 2113 OrderByComparator<AssetCategory> orderByComparator) 2114 throws com.liferay.portlet.asset.NoSuchCategoryException { 2115 return getPersistence() 2116 .findByG_P_V_First(groupId, parentCategoryId, vocabularyId, 2117 orderByComparator); 2118 } 2119 2120 /** 2121 * Returns the first asset category in the ordered set where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 2122 * 2123 * @param groupId the group ID 2124 * @param parentCategoryId the parent category ID 2125 * @param vocabularyId the vocabulary ID 2126 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2127 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 2128 */ 2129 public static AssetCategory fetchByG_P_V_First(long groupId, 2130 long parentCategoryId, long vocabularyId, 2131 OrderByComparator<AssetCategory> orderByComparator) { 2132 return getPersistence() 2133 .fetchByG_P_V_First(groupId, parentCategoryId, vocabularyId, 2134 orderByComparator); 2135 } 2136 2137 /** 2138 * Returns the last asset category in the ordered set where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 2139 * 2140 * @param groupId the group ID 2141 * @param parentCategoryId the parent category ID 2142 * @param vocabularyId the vocabulary ID 2143 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2144 * @return the last matching asset category 2145 * @throws NoSuchCategoryException if a matching asset category could not be found 2146 */ 2147 public static AssetCategory findByG_P_V_Last(long groupId, 2148 long parentCategoryId, long vocabularyId, 2149 OrderByComparator<AssetCategory> orderByComparator) 2150 throws com.liferay.portlet.asset.NoSuchCategoryException { 2151 return getPersistence() 2152 .findByG_P_V_Last(groupId, parentCategoryId, vocabularyId, 2153 orderByComparator); 2154 } 2155 2156 /** 2157 * Returns the last asset category in the ordered set where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 2158 * 2159 * @param groupId the group ID 2160 * @param parentCategoryId the parent category ID 2161 * @param vocabularyId the vocabulary ID 2162 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2163 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 2164 */ 2165 public static AssetCategory fetchByG_P_V_Last(long groupId, 2166 long parentCategoryId, long vocabularyId, 2167 OrderByComparator<AssetCategory> orderByComparator) { 2168 return getPersistence() 2169 .fetchByG_P_V_Last(groupId, parentCategoryId, vocabularyId, 2170 orderByComparator); 2171 } 2172 2173 /** 2174 * Returns the asset categories before and after the current asset category in the ordered set where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 2175 * 2176 * @param categoryId the primary key of the current asset category 2177 * @param groupId the group ID 2178 * @param parentCategoryId the parent category ID 2179 * @param vocabularyId the vocabulary ID 2180 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2181 * @return the previous, current, and next asset category 2182 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 2183 */ 2184 public static AssetCategory[] findByG_P_V_PrevAndNext(long categoryId, 2185 long groupId, long parentCategoryId, long vocabularyId, 2186 OrderByComparator<AssetCategory> orderByComparator) 2187 throws com.liferay.portlet.asset.NoSuchCategoryException { 2188 return getPersistence() 2189 .findByG_P_V_PrevAndNext(categoryId, groupId, 2190 parentCategoryId, vocabularyId, orderByComparator); 2191 } 2192 2193 /** 2194 * Returns all the asset categories that the user has permission to view where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 2195 * 2196 * @param groupId the group ID 2197 * @param parentCategoryId the parent category ID 2198 * @param vocabularyId the vocabulary ID 2199 * @return the matching asset categories that the user has permission to view 2200 */ 2201 public static List<AssetCategory> filterFindByG_P_V(long groupId, 2202 long parentCategoryId, long vocabularyId) { 2203 return getPersistence() 2204 .filterFindByG_P_V(groupId, parentCategoryId, vocabularyId); 2205 } 2206 2207 /** 2208 * Returns a range of all the asset categories that the user has permission to view where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 2209 * 2210 * <p> 2211 * 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. 2212 * </p> 2213 * 2214 * @param groupId the group ID 2215 * @param parentCategoryId the parent category ID 2216 * @param vocabularyId the vocabulary ID 2217 * @param start the lower bound of the range of asset categories 2218 * @param end the upper bound of the range of asset categories (not inclusive) 2219 * @return the range of matching asset categories that the user has permission to view 2220 */ 2221 public static List<AssetCategory> filterFindByG_P_V(long groupId, 2222 long parentCategoryId, long vocabularyId, int start, int end) { 2223 return getPersistence() 2224 .filterFindByG_P_V(groupId, parentCategoryId, vocabularyId, 2225 start, end); 2226 } 2227 2228 /** 2229 * Returns an ordered range of all the asset categories that the user has permissions to view where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 2230 * 2231 * <p> 2232 * 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. 2233 * </p> 2234 * 2235 * @param groupId the group ID 2236 * @param parentCategoryId the parent category ID 2237 * @param vocabularyId the vocabulary ID 2238 * @param start the lower bound of the range of asset categories 2239 * @param end the upper bound of the range of asset categories (not inclusive) 2240 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2241 * @return the ordered range of matching asset categories that the user has permission to view 2242 */ 2243 public static List<AssetCategory> filterFindByG_P_V(long groupId, 2244 long parentCategoryId, long vocabularyId, int start, int end, 2245 OrderByComparator<AssetCategory> orderByComparator) { 2246 return getPersistence() 2247 .filterFindByG_P_V(groupId, parentCategoryId, vocabularyId, 2248 start, end, orderByComparator); 2249 } 2250 2251 /** 2252 * 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 = ?. 2253 * 2254 * @param categoryId the primary key of the current asset category 2255 * @param groupId the group ID 2256 * @param parentCategoryId the parent category ID 2257 * @param vocabularyId the vocabulary ID 2258 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2259 * @return the previous, current, and next asset category 2260 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 2261 */ 2262 public static AssetCategory[] filterFindByG_P_V_PrevAndNext( 2263 long categoryId, long groupId, long parentCategoryId, 2264 long vocabularyId, OrderByComparator<AssetCategory> orderByComparator) 2265 throws com.liferay.portlet.asset.NoSuchCategoryException { 2266 return getPersistence() 2267 .filterFindByG_P_V_PrevAndNext(categoryId, groupId, 2268 parentCategoryId, vocabularyId, orderByComparator); 2269 } 2270 2271 /** 2272 * Removes all the asset categories where groupId = ? and parentCategoryId = ? and vocabularyId = ? from the database. 2273 * 2274 * @param groupId the group ID 2275 * @param parentCategoryId the parent category ID 2276 * @param vocabularyId the vocabulary ID 2277 */ 2278 public static void removeByG_P_V(long groupId, long parentCategoryId, 2279 long vocabularyId) { 2280 getPersistence().removeByG_P_V(groupId, parentCategoryId, vocabularyId); 2281 } 2282 2283 /** 2284 * Returns the number of asset categories where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 2285 * 2286 * @param groupId the group ID 2287 * @param parentCategoryId the parent category ID 2288 * @param vocabularyId the vocabulary ID 2289 * @return the number of matching asset categories 2290 */ 2291 public static int countByG_P_V(long groupId, long parentCategoryId, 2292 long vocabularyId) { 2293 return getPersistence() 2294 .countByG_P_V(groupId, parentCategoryId, vocabularyId); 2295 } 2296 2297 /** 2298 * Returns the number of asset categories that the user has permission to view where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 2299 * 2300 * @param groupId the group ID 2301 * @param parentCategoryId the parent category ID 2302 * @param vocabularyId the vocabulary ID 2303 * @return the number of matching asset categories that the user has permission to view 2304 */ 2305 public static int filterCountByG_P_V(long groupId, long parentCategoryId, 2306 long vocabularyId) { 2307 return getPersistence() 2308 .filterCountByG_P_V(groupId, parentCategoryId, vocabularyId); 2309 } 2310 2311 /** 2312 * Returns all the asset categories where groupId = ? and name LIKE ? and vocabularyId = ?. 2313 * 2314 * @param groupId the group ID 2315 * @param name the name 2316 * @param vocabularyId the vocabulary ID 2317 * @return the matching asset categories 2318 */ 2319 public static List<AssetCategory> findByG_LikeN_V(long groupId, 2320 java.lang.String name, long vocabularyId) { 2321 return getPersistence().findByG_LikeN_V(groupId, name, vocabularyId); 2322 } 2323 2324 /** 2325 * Returns a range of all the asset categories where groupId = ? and name LIKE ? and vocabularyId = ?. 2326 * 2327 * <p> 2328 * 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. 2329 * </p> 2330 * 2331 * @param groupId the group ID 2332 * @param name the name 2333 * @param vocabularyId the vocabulary ID 2334 * @param start the lower bound of the range of asset categories 2335 * @param end the upper bound of the range of asset categories (not inclusive) 2336 * @return the range of matching asset categories 2337 */ 2338 public static List<AssetCategory> findByG_LikeN_V(long groupId, 2339 java.lang.String name, long vocabularyId, int start, int end) { 2340 return getPersistence() 2341 .findByG_LikeN_V(groupId, name, vocabularyId, start, end); 2342 } 2343 2344 /** 2345 * Returns an ordered range of all the asset categories where groupId = ? and name LIKE ? and vocabularyId = ?. 2346 * 2347 * <p> 2348 * 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. 2349 * </p> 2350 * 2351 * @param groupId the group ID 2352 * @param name the name 2353 * @param vocabularyId the vocabulary ID 2354 * @param start the lower bound of the range of asset categories 2355 * @param end the upper bound of the range of asset categories (not inclusive) 2356 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2357 * @return the ordered range of matching asset categories 2358 */ 2359 public static List<AssetCategory> findByG_LikeN_V(long groupId, 2360 java.lang.String name, long vocabularyId, int start, int end, 2361 OrderByComparator<AssetCategory> orderByComparator) { 2362 return getPersistence() 2363 .findByG_LikeN_V(groupId, name, vocabularyId, start, end, 2364 orderByComparator); 2365 } 2366 2367 /** 2368 * Returns an ordered range of all the asset categories where groupId = ? and name LIKE ? and vocabularyId = ?. 2369 * 2370 * <p> 2371 * 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. 2372 * </p> 2373 * 2374 * @param groupId the group ID 2375 * @param name the name 2376 * @param vocabularyId the vocabulary ID 2377 * @param start the lower bound of the range of asset categories 2378 * @param end the upper bound of the range of asset categories (not inclusive) 2379 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2380 * @param retrieveFromCache whether to retrieve from the finder cache 2381 * @return the ordered range of matching asset categories 2382 */ 2383 public static List<AssetCategory> findByG_LikeN_V(long groupId, 2384 java.lang.String name, long vocabularyId, int start, int end, 2385 OrderByComparator<AssetCategory> orderByComparator, 2386 boolean retrieveFromCache) { 2387 return getPersistence() 2388 .findByG_LikeN_V(groupId, name, vocabularyId, start, end, 2389 orderByComparator, retrieveFromCache); 2390 } 2391 2392 /** 2393 * Returns the first asset category in the ordered set where groupId = ? and name LIKE ? and vocabularyId = ?. 2394 * 2395 * @param groupId the group ID 2396 * @param name the name 2397 * @param vocabularyId the vocabulary ID 2398 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2399 * @return the first matching asset category 2400 * @throws NoSuchCategoryException if a matching asset category could not be found 2401 */ 2402 public static AssetCategory findByG_LikeN_V_First(long groupId, 2403 java.lang.String name, long vocabularyId, 2404 OrderByComparator<AssetCategory> orderByComparator) 2405 throws com.liferay.portlet.asset.NoSuchCategoryException { 2406 return getPersistence() 2407 .findByG_LikeN_V_First(groupId, name, vocabularyId, 2408 orderByComparator); 2409 } 2410 2411 /** 2412 * Returns the first asset category in the ordered set where groupId = ? and name LIKE ? and vocabularyId = ?. 2413 * 2414 * @param groupId the group ID 2415 * @param name the name 2416 * @param vocabularyId the vocabulary ID 2417 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2418 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 2419 */ 2420 public static AssetCategory fetchByG_LikeN_V_First(long groupId, 2421 java.lang.String name, long vocabularyId, 2422 OrderByComparator<AssetCategory> orderByComparator) { 2423 return getPersistence() 2424 .fetchByG_LikeN_V_First(groupId, name, vocabularyId, 2425 orderByComparator); 2426 } 2427 2428 /** 2429 * Returns the last asset category in the ordered set where groupId = ? and name LIKE ? and vocabularyId = ?. 2430 * 2431 * @param groupId the group ID 2432 * @param name the name 2433 * @param vocabularyId the vocabulary ID 2434 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2435 * @return the last matching asset category 2436 * @throws NoSuchCategoryException if a matching asset category could not be found 2437 */ 2438 public static AssetCategory findByG_LikeN_V_Last(long groupId, 2439 java.lang.String name, long vocabularyId, 2440 OrderByComparator<AssetCategory> orderByComparator) 2441 throws com.liferay.portlet.asset.NoSuchCategoryException { 2442 return getPersistence() 2443 .findByG_LikeN_V_Last(groupId, name, vocabularyId, 2444 orderByComparator); 2445 } 2446 2447 /** 2448 * Returns the last asset category in the ordered set where groupId = ? and name LIKE ? and vocabularyId = ?. 2449 * 2450 * @param groupId the group ID 2451 * @param name the name 2452 * @param vocabularyId the vocabulary ID 2453 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2454 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 2455 */ 2456 public static AssetCategory fetchByG_LikeN_V_Last(long groupId, 2457 java.lang.String name, long vocabularyId, 2458 OrderByComparator<AssetCategory> orderByComparator) { 2459 return getPersistence() 2460 .fetchByG_LikeN_V_Last(groupId, name, vocabularyId, 2461 orderByComparator); 2462 } 2463 2464 /** 2465 * Returns the asset categories before and after the current asset category in the ordered set where groupId = ? and name LIKE ? and vocabularyId = ?. 2466 * 2467 * @param categoryId the primary key of the current asset category 2468 * @param groupId the group ID 2469 * @param name the name 2470 * @param vocabularyId the vocabulary ID 2471 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2472 * @return the previous, current, and next asset category 2473 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 2474 */ 2475 public static AssetCategory[] findByG_LikeN_V_PrevAndNext(long categoryId, 2476 long groupId, java.lang.String name, long vocabularyId, 2477 OrderByComparator<AssetCategory> orderByComparator) 2478 throws com.liferay.portlet.asset.NoSuchCategoryException { 2479 return getPersistence() 2480 .findByG_LikeN_V_PrevAndNext(categoryId, groupId, name, 2481 vocabularyId, orderByComparator); 2482 } 2483 2484 /** 2485 * Returns all the asset categories that the user has permission to view where groupId = ? and name LIKE ? and vocabularyId = ?. 2486 * 2487 * @param groupId the group ID 2488 * @param name the name 2489 * @param vocabularyId the vocabulary ID 2490 * @return the matching asset categories that the user has permission to view 2491 */ 2492 public static List<AssetCategory> filterFindByG_LikeN_V(long groupId, 2493 java.lang.String name, long vocabularyId) { 2494 return getPersistence() 2495 .filterFindByG_LikeN_V(groupId, name, vocabularyId); 2496 } 2497 2498 /** 2499 * Returns a range of all the asset categories that the user has permission to view where groupId = ? and name LIKE ? and vocabularyId = ?. 2500 * 2501 * <p> 2502 * 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. 2503 * </p> 2504 * 2505 * @param groupId the group ID 2506 * @param name the name 2507 * @param vocabularyId the vocabulary ID 2508 * @param start the lower bound of the range of asset categories 2509 * @param end the upper bound of the range of asset categories (not inclusive) 2510 * @return the range of matching asset categories that the user has permission to view 2511 */ 2512 public static List<AssetCategory> filterFindByG_LikeN_V(long groupId, 2513 java.lang.String name, long vocabularyId, int start, int end) { 2514 return getPersistence() 2515 .filterFindByG_LikeN_V(groupId, name, vocabularyId, start, 2516 end); 2517 } 2518 2519 /** 2520 * Returns an ordered range of all the asset categories that the user has permissions to view where groupId = ? and name LIKE ? and vocabularyId = ?. 2521 * 2522 * <p> 2523 * 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. 2524 * </p> 2525 * 2526 * @param groupId the group ID 2527 * @param name the name 2528 * @param vocabularyId the vocabulary ID 2529 * @param start the lower bound of the range of asset categories 2530 * @param end the upper bound of the range of asset categories (not inclusive) 2531 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2532 * @return the ordered range of matching asset categories that the user has permission to view 2533 */ 2534 public static List<AssetCategory> filterFindByG_LikeN_V(long groupId, 2535 java.lang.String name, long vocabularyId, int start, int end, 2536 OrderByComparator<AssetCategory> orderByComparator) { 2537 return getPersistence() 2538 .filterFindByG_LikeN_V(groupId, name, vocabularyId, start, 2539 end, orderByComparator); 2540 } 2541 2542 /** 2543 * 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 = ?. 2544 * 2545 * @param categoryId the primary key of the current asset category 2546 * @param groupId the group ID 2547 * @param name the name 2548 * @param vocabularyId the vocabulary ID 2549 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2550 * @return the previous, current, and next asset category 2551 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 2552 */ 2553 public static AssetCategory[] filterFindByG_LikeN_V_PrevAndNext( 2554 long categoryId, long groupId, java.lang.String name, 2555 long vocabularyId, OrderByComparator<AssetCategory> orderByComparator) 2556 throws com.liferay.portlet.asset.NoSuchCategoryException { 2557 return getPersistence() 2558 .filterFindByG_LikeN_V_PrevAndNext(categoryId, groupId, 2559 name, vocabularyId, orderByComparator); 2560 } 2561 2562 /** 2563 * Returns all the asset categories that the user has permission to view where groupId = ? and name LIKE ? and vocabularyId = any ?. 2564 * 2565 * @param groupId the group ID 2566 * @param name the name 2567 * @param vocabularyIds the vocabulary IDs 2568 * @return the matching asset categories that the user has permission to view 2569 */ 2570 public static List<AssetCategory> filterFindByG_LikeN_V(long groupId, 2571 java.lang.String name, long[] vocabularyIds) { 2572 return getPersistence() 2573 .filterFindByG_LikeN_V(groupId, name, vocabularyIds); 2574 } 2575 2576 /** 2577 * Returns a range of all the asset categories that the user has permission to view where groupId = ? and name LIKE ? and vocabularyId = any ?. 2578 * 2579 * <p> 2580 * 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. 2581 * </p> 2582 * 2583 * @param groupId the group ID 2584 * @param name the name 2585 * @param vocabularyIds the vocabulary IDs 2586 * @param start the lower bound of the range of asset categories 2587 * @param end the upper bound of the range of asset categories (not inclusive) 2588 * @return the range of matching asset categories that the user has permission to view 2589 */ 2590 public static List<AssetCategory> filterFindByG_LikeN_V(long groupId, 2591 java.lang.String name, long[] vocabularyIds, int start, int end) { 2592 return getPersistence() 2593 .filterFindByG_LikeN_V(groupId, name, vocabularyIds, start, 2594 end); 2595 } 2596 2597 /** 2598 * Returns an ordered range of all the asset categories that the user has permission to view where groupId = ? and name LIKE ? and vocabularyId = any ?. 2599 * 2600 * <p> 2601 * 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. 2602 * </p> 2603 * 2604 * @param groupId the group ID 2605 * @param name the name 2606 * @param vocabularyIds the vocabulary IDs 2607 * @param start the lower bound of the range of asset categories 2608 * @param end the upper bound of the range of asset categories (not inclusive) 2609 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2610 * @return the ordered range of matching asset categories that the user has permission to view 2611 */ 2612 public static List<AssetCategory> filterFindByG_LikeN_V(long groupId, 2613 java.lang.String name, long[] vocabularyIds, int start, int end, 2614 OrderByComparator<AssetCategory> orderByComparator) { 2615 return getPersistence() 2616 .filterFindByG_LikeN_V(groupId, name, vocabularyIds, start, 2617 end, orderByComparator); 2618 } 2619 2620 /** 2621 * Returns all the asset categories where groupId = ? and name LIKE ? and vocabularyId = any ?. 2622 * 2623 * <p> 2624 * 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. 2625 * </p> 2626 * 2627 * @param groupId the group ID 2628 * @param name the name 2629 * @param vocabularyIds the vocabulary IDs 2630 * @return the matching asset categories 2631 */ 2632 public static List<AssetCategory> findByG_LikeN_V(long groupId, 2633 java.lang.String name, long[] vocabularyIds) { 2634 return getPersistence().findByG_LikeN_V(groupId, name, vocabularyIds); 2635 } 2636 2637 /** 2638 * Returns a range of all the asset categories where groupId = ? and name LIKE ? and vocabularyId = any ?. 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 groupId the group ID 2645 * @param name the name 2646 * @param vocabularyIds the vocabulary IDs 2647 * @param start the lower bound of the range of asset categories 2648 * @param end the upper bound of the range of asset categories (not inclusive) 2649 * @return the range of matching asset categories 2650 */ 2651 public static List<AssetCategory> findByG_LikeN_V(long groupId, 2652 java.lang.String name, long[] vocabularyIds, int start, int end) { 2653 return getPersistence() 2654 .findByG_LikeN_V(groupId, name, vocabularyIds, start, end); 2655 } 2656 2657 /** 2658 * Returns an ordered range of all the asset categories where groupId = ? and name LIKE ? and vocabularyId = any ?. 2659 * 2660 * <p> 2661 * 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. 2662 * </p> 2663 * 2664 * @param groupId the group ID 2665 * @param name the name 2666 * @param vocabularyIds the vocabulary IDs 2667 * @param start the lower bound of the range of asset categories 2668 * @param end the upper bound of the range of asset categories (not inclusive) 2669 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2670 * @return the ordered range of matching asset categories 2671 */ 2672 public static List<AssetCategory> findByG_LikeN_V(long groupId, 2673 java.lang.String name, long[] vocabularyIds, int start, int end, 2674 OrderByComparator<AssetCategory> orderByComparator) { 2675 return getPersistence() 2676 .findByG_LikeN_V(groupId, name, vocabularyIds, start, end, 2677 orderByComparator); 2678 } 2679 2680 /** 2681 * Returns an ordered range of all the asset categories where groupId = ? and name LIKE ? and vocabularyId = ?, optionally using the finder cache. 2682 * 2683 * <p> 2684 * 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. 2685 * </p> 2686 * 2687 * @param groupId the group ID 2688 * @param name the name 2689 * @param vocabularyId the vocabulary ID 2690 * @param start the lower bound of the range of asset categories 2691 * @param end the upper bound of the range of asset categories (not inclusive) 2692 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2693 * @param retrieveFromCache whether to retrieve from the finder cache 2694 * @return the ordered range of matching asset categories 2695 */ 2696 public static List<AssetCategory> findByG_LikeN_V(long groupId, 2697 java.lang.String name, long[] vocabularyIds, int start, int end, 2698 OrderByComparator<AssetCategory> orderByComparator, 2699 boolean retrieveFromCache) { 2700 return getPersistence() 2701 .findByG_LikeN_V(groupId, name, vocabularyIds, start, end, 2702 orderByComparator, retrieveFromCache); 2703 } 2704 2705 /** 2706 * Removes all the asset categories where groupId = ? and name LIKE ? and vocabularyId = ? from the database. 2707 * 2708 * @param groupId the group ID 2709 * @param name the name 2710 * @param vocabularyId the vocabulary ID 2711 */ 2712 public static void removeByG_LikeN_V(long groupId, java.lang.String name, 2713 long vocabularyId) { 2714 getPersistence().removeByG_LikeN_V(groupId, name, vocabularyId); 2715 } 2716 2717 /** 2718 * Returns the number of asset categories where groupId = ? and name LIKE ? and vocabularyId = ?. 2719 * 2720 * @param groupId the group ID 2721 * @param name the name 2722 * @param vocabularyId the vocabulary ID 2723 * @return the number of matching asset categories 2724 */ 2725 public static int countByG_LikeN_V(long groupId, java.lang.String name, 2726 long vocabularyId) { 2727 return getPersistence().countByG_LikeN_V(groupId, name, vocabularyId); 2728 } 2729 2730 /** 2731 * Returns the number of asset categories where groupId = ? and name LIKE ? and vocabularyId = any ?. 2732 * 2733 * @param groupId the group ID 2734 * @param name the name 2735 * @param vocabularyIds the vocabulary IDs 2736 * @return the number of matching asset categories 2737 */ 2738 public static int countByG_LikeN_V(long groupId, java.lang.String name, 2739 long[] vocabularyIds) { 2740 return getPersistence().countByG_LikeN_V(groupId, name, vocabularyIds); 2741 } 2742 2743 /** 2744 * Returns the number of asset categories that the user has permission to view where groupId = ? and name LIKE ? and vocabularyId = ?. 2745 * 2746 * @param groupId the group ID 2747 * @param name the name 2748 * @param vocabularyId the vocabulary ID 2749 * @return the number of matching asset categories that the user has permission to view 2750 */ 2751 public static int filterCountByG_LikeN_V(long groupId, 2752 java.lang.String name, long vocabularyId) { 2753 return getPersistence() 2754 .filterCountByG_LikeN_V(groupId, name, vocabularyId); 2755 } 2756 2757 /** 2758 * Returns the number of asset categories that the user has permission to view where groupId = ? and name LIKE ? and vocabularyId = any ?. 2759 * 2760 * @param groupId the group ID 2761 * @param name the name 2762 * @param vocabularyIds the vocabulary IDs 2763 * @return the number of matching asset categories that the user has permission to view 2764 */ 2765 public static int filterCountByG_LikeN_V(long groupId, 2766 java.lang.String name, long[] vocabularyIds) { 2767 return getPersistence() 2768 .filterCountByG_LikeN_V(groupId, name, vocabularyIds); 2769 } 2770 2771 /** 2772 * Returns the asset category where parentCategoryId = ? and name = ? and vocabularyId = ? or throws a {@link NoSuchCategoryException} if it could not be found. 2773 * 2774 * @param parentCategoryId the parent category ID 2775 * @param name the name 2776 * @param vocabularyId the vocabulary ID 2777 * @return the matching asset category 2778 * @throws NoSuchCategoryException if a matching asset category could not be found 2779 */ 2780 public static AssetCategory findByP_N_V(long parentCategoryId, 2781 java.lang.String name, long vocabularyId) 2782 throws com.liferay.portlet.asset.NoSuchCategoryException { 2783 return getPersistence().findByP_N_V(parentCategoryId, name, vocabularyId); 2784 } 2785 2786 /** 2787 * 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. 2788 * 2789 * @param parentCategoryId the parent category ID 2790 * @param name the name 2791 * @param vocabularyId the vocabulary ID 2792 * @return the matching asset category, or <code>null</code> if a matching asset category could not be found 2793 */ 2794 public static AssetCategory fetchByP_N_V(long parentCategoryId, 2795 java.lang.String name, long vocabularyId) { 2796 return getPersistence() 2797 .fetchByP_N_V(parentCategoryId, name, vocabularyId); 2798 } 2799 2800 /** 2801 * 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. 2802 * 2803 * @param parentCategoryId the parent category ID 2804 * @param name the name 2805 * @param vocabularyId the vocabulary ID 2806 * @param retrieveFromCache whether to retrieve from the finder cache 2807 * @return the matching asset category, or <code>null</code> if a matching asset category could not be found 2808 */ 2809 public static AssetCategory fetchByP_N_V(long parentCategoryId, 2810 java.lang.String name, long vocabularyId, boolean retrieveFromCache) { 2811 return getPersistence() 2812 .fetchByP_N_V(parentCategoryId, name, vocabularyId, 2813 retrieveFromCache); 2814 } 2815 2816 /** 2817 * Removes the asset category where parentCategoryId = ? and name = ? and vocabularyId = ? from the database. 2818 * 2819 * @param parentCategoryId the parent category ID 2820 * @param name the name 2821 * @param vocabularyId the vocabulary ID 2822 * @return the asset category that was removed 2823 */ 2824 public static AssetCategory removeByP_N_V(long parentCategoryId, 2825 java.lang.String name, long vocabularyId) 2826 throws com.liferay.portlet.asset.NoSuchCategoryException { 2827 return getPersistence() 2828 .removeByP_N_V(parentCategoryId, name, vocabularyId); 2829 } 2830 2831 /** 2832 * Returns the number of asset categories where parentCategoryId = ? and name = ? and vocabularyId = ?. 2833 * 2834 * @param parentCategoryId the parent category ID 2835 * @param name the name 2836 * @param vocabularyId the vocabulary ID 2837 * @return the number of matching asset categories 2838 */ 2839 public static int countByP_N_V(long parentCategoryId, 2840 java.lang.String name, long vocabularyId) { 2841 return getPersistence() 2842 .countByP_N_V(parentCategoryId, name, vocabularyId); 2843 } 2844 2845 /** 2846 * Returns all the asset categories where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2847 * 2848 * @param groupId the group ID 2849 * @param parentCategoryId the parent category ID 2850 * @param name the name 2851 * @param vocabularyId the vocabulary ID 2852 * @return the matching asset categories 2853 */ 2854 public static List<AssetCategory> findByG_P_N_V(long groupId, 2855 long parentCategoryId, java.lang.String name, long vocabularyId) { 2856 return getPersistence() 2857 .findByG_P_N_V(groupId, parentCategoryId, name, vocabularyId); 2858 } 2859 2860 /** 2861 * Returns a range of all the asset categories where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2862 * 2863 * <p> 2864 * 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. 2865 * </p> 2866 * 2867 * @param groupId the group ID 2868 * @param parentCategoryId the parent category ID 2869 * @param name the name 2870 * @param vocabularyId the vocabulary ID 2871 * @param start the lower bound of the range of asset categories 2872 * @param end the upper bound of the range of asset categories (not inclusive) 2873 * @return the range of matching asset categories 2874 */ 2875 public static List<AssetCategory> findByG_P_N_V(long groupId, 2876 long parentCategoryId, java.lang.String name, long vocabularyId, 2877 int start, int end) { 2878 return getPersistence() 2879 .findByG_P_N_V(groupId, parentCategoryId, name, 2880 vocabularyId, start, end); 2881 } 2882 2883 /** 2884 * Returns an ordered range of all the asset categories where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2885 * 2886 * <p> 2887 * 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. 2888 * </p> 2889 * 2890 * @param groupId the group ID 2891 * @param parentCategoryId the parent category ID 2892 * @param name the name 2893 * @param vocabularyId the vocabulary ID 2894 * @param start the lower bound of the range of asset categories 2895 * @param end the upper bound of the range of asset categories (not inclusive) 2896 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2897 * @return the ordered range of matching asset categories 2898 */ 2899 public static List<AssetCategory> findByG_P_N_V(long groupId, 2900 long parentCategoryId, java.lang.String name, long vocabularyId, 2901 int start, int end, OrderByComparator<AssetCategory> orderByComparator) { 2902 return getPersistence() 2903 .findByG_P_N_V(groupId, parentCategoryId, name, 2904 vocabularyId, start, end, orderByComparator); 2905 } 2906 2907 /** 2908 * Returns an ordered range of all the asset categories where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2909 * 2910 * <p> 2911 * 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. 2912 * </p> 2913 * 2914 * @param groupId the group ID 2915 * @param parentCategoryId the parent category ID 2916 * @param name the name 2917 * @param vocabularyId the vocabulary ID 2918 * @param start the lower bound of the range of asset categories 2919 * @param end the upper bound of the range of asset categories (not inclusive) 2920 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2921 * @param retrieveFromCache whether to retrieve from the finder cache 2922 * @return the ordered range of matching asset categories 2923 */ 2924 public static List<AssetCategory> findByG_P_N_V(long groupId, 2925 long parentCategoryId, java.lang.String name, long vocabularyId, 2926 int start, int end, OrderByComparator<AssetCategory> orderByComparator, 2927 boolean retrieveFromCache) { 2928 return getPersistence() 2929 .findByG_P_N_V(groupId, parentCategoryId, name, 2930 vocabularyId, start, end, orderByComparator, retrieveFromCache); 2931 } 2932 2933 /** 2934 * Returns the first asset category in the ordered set where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2935 * 2936 * @param groupId the group ID 2937 * @param parentCategoryId the parent category ID 2938 * @param name the name 2939 * @param vocabularyId the vocabulary ID 2940 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2941 * @return the first matching asset category 2942 * @throws NoSuchCategoryException if a matching asset category could not be found 2943 */ 2944 public static AssetCategory findByG_P_N_V_First(long groupId, 2945 long parentCategoryId, java.lang.String name, long vocabularyId, 2946 OrderByComparator<AssetCategory> orderByComparator) 2947 throws com.liferay.portlet.asset.NoSuchCategoryException { 2948 return getPersistence() 2949 .findByG_P_N_V_First(groupId, parentCategoryId, name, 2950 vocabularyId, orderByComparator); 2951 } 2952 2953 /** 2954 * Returns the first asset category in the ordered set where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2955 * 2956 * @param groupId the group ID 2957 * @param parentCategoryId the parent category ID 2958 * @param name the name 2959 * @param vocabularyId the vocabulary ID 2960 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2961 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 2962 */ 2963 public static AssetCategory fetchByG_P_N_V_First(long groupId, 2964 long parentCategoryId, java.lang.String name, long vocabularyId, 2965 OrderByComparator<AssetCategory> orderByComparator) { 2966 return getPersistence() 2967 .fetchByG_P_N_V_First(groupId, parentCategoryId, name, 2968 vocabularyId, orderByComparator); 2969 } 2970 2971 /** 2972 * Returns the last asset category in the ordered set where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2973 * 2974 * @param groupId the group ID 2975 * @param parentCategoryId the parent category ID 2976 * @param name the name 2977 * @param vocabularyId the vocabulary ID 2978 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2979 * @return the last matching asset category 2980 * @throws NoSuchCategoryException if a matching asset category could not be found 2981 */ 2982 public static AssetCategory findByG_P_N_V_Last(long groupId, 2983 long parentCategoryId, java.lang.String name, long vocabularyId, 2984 OrderByComparator<AssetCategory> orderByComparator) 2985 throws com.liferay.portlet.asset.NoSuchCategoryException { 2986 return getPersistence() 2987 .findByG_P_N_V_Last(groupId, parentCategoryId, name, 2988 vocabularyId, orderByComparator); 2989 } 2990 2991 /** 2992 * Returns the last asset category in the ordered set where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2993 * 2994 * @param groupId the group ID 2995 * @param parentCategoryId the parent category ID 2996 * @param name the name 2997 * @param vocabularyId the vocabulary ID 2998 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2999 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 3000 */ 3001 public static AssetCategory fetchByG_P_N_V_Last(long groupId, 3002 long parentCategoryId, java.lang.String name, long vocabularyId, 3003 OrderByComparator<AssetCategory> orderByComparator) { 3004 return getPersistence() 3005 .fetchByG_P_N_V_Last(groupId, parentCategoryId, name, 3006 vocabularyId, orderByComparator); 3007 } 3008 3009 /** 3010 * Returns the asset categories before and after the current asset category in the ordered set where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 3011 * 3012 * @param categoryId the primary key of the current asset category 3013 * @param groupId the group ID 3014 * @param parentCategoryId the parent category ID 3015 * @param name the name 3016 * @param vocabularyId the vocabulary ID 3017 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3018 * @return the previous, current, and next asset category 3019 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 3020 */ 3021 public static AssetCategory[] findByG_P_N_V_PrevAndNext(long categoryId, 3022 long groupId, long parentCategoryId, java.lang.String name, 3023 long vocabularyId, OrderByComparator<AssetCategory> orderByComparator) 3024 throws com.liferay.portlet.asset.NoSuchCategoryException { 3025 return getPersistence() 3026 .findByG_P_N_V_PrevAndNext(categoryId, groupId, 3027 parentCategoryId, name, vocabularyId, orderByComparator); 3028 } 3029 3030 /** 3031 * Returns all the asset categories that the user has permission to view where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 3032 * 3033 * @param groupId the group ID 3034 * @param parentCategoryId the parent category ID 3035 * @param name the name 3036 * @param vocabularyId the vocabulary ID 3037 * @return the matching asset categories that the user has permission to view 3038 */ 3039 public static List<AssetCategory> filterFindByG_P_N_V(long groupId, 3040 long parentCategoryId, java.lang.String name, long vocabularyId) { 3041 return getPersistence() 3042 .filterFindByG_P_N_V(groupId, parentCategoryId, name, 3043 vocabularyId); 3044 } 3045 3046 /** 3047 * Returns a range of all the asset categories that the user has permission to view where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 3048 * 3049 * <p> 3050 * 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. 3051 * </p> 3052 * 3053 * @param groupId the group ID 3054 * @param parentCategoryId the parent category ID 3055 * @param name the name 3056 * @param vocabularyId the vocabulary ID 3057 * @param start the lower bound of the range of asset categories 3058 * @param end the upper bound of the range of asset categories (not inclusive) 3059 * @return the range of matching asset categories that the user has permission to view 3060 */ 3061 public static List<AssetCategory> filterFindByG_P_N_V(long groupId, 3062 long parentCategoryId, java.lang.String name, long vocabularyId, 3063 int start, int end) { 3064 return getPersistence() 3065 .filterFindByG_P_N_V(groupId, parentCategoryId, name, 3066 vocabularyId, start, end); 3067 } 3068 3069 /** 3070 * Returns an ordered range of all the asset categories that the user has permissions to view where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 3071 * 3072 * <p> 3073 * 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. 3074 * </p> 3075 * 3076 * @param groupId the group ID 3077 * @param parentCategoryId the parent category ID 3078 * @param name the name 3079 * @param vocabularyId the vocabulary ID 3080 * @param start the lower bound of the range of asset categories 3081 * @param end the upper bound of the range of asset categories (not inclusive) 3082 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3083 * @return the ordered range of matching asset categories that the user has permission to view 3084 */ 3085 public static List<AssetCategory> filterFindByG_P_N_V(long groupId, 3086 long parentCategoryId, java.lang.String name, long vocabularyId, 3087 int start, int end, OrderByComparator<AssetCategory> orderByComparator) { 3088 return getPersistence() 3089 .filterFindByG_P_N_V(groupId, parentCategoryId, name, 3090 vocabularyId, start, end, orderByComparator); 3091 } 3092 3093 /** 3094 * 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 = ?. 3095 * 3096 * @param categoryId the primary key of the current asset category 3097 * @param groupId the group ID 3098 * @param parentCategoryId the parent category ID 3099 * @param name the name 3100 * @param vocabularyId the vocabulary ID 3101 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 3102 * @return the previous, current, and next asset category 3103 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 3104 */ 3105 public static AssetCategory[] filterFindByG_P_N_V_PrevAndNext( 3106 long categoryId, long groupId, long parentCategoryId, 3107 java.lang.String name, long vocabularyId, 3108 OrderByComparator<AssetCategory> orderByComparator) 3109 throws com.liferay.portlet.asset.NoSuchCategoryException { 3110 return getPersistence() 3111 .filterFindByG_P_N_V_PrevAndNext(categoryId, groupId, 3112 parentCategoryId, name, vocabularyId, orderByComparator); 3113 } 3114 3115 /** 3116 * Removes all the asset categories where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ? from the database. 3117 * 3118 * @param groupId the group ID 3119 * @param parentCategoryId the parent category ID 3120 * @param name the name 3121 * @param vocabularyId the vocabulary ID 3122 */ 3123 public static void removeByG_P_N_V(long groupId, long parentCategoryId, 3124 java.lang.String name, long vocabularyId) { 3125 getPersistence() 3126 .removeByG_P_N_V(groupId, parentCategoryId, name, vocabularyId); 3127 } 3128 3129 /** 3130 * Returns the number of asset categories where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 3131 * 3132 * @param groupId the group ID 3133 * @param parentCategoryId the parent category ID 3134 * @param name the name 3135 * @param vocabularyId the vocabulary ID 3136 * @return the number of matching asset categories 3137 */ 3138 public static int countByG_P_N_V(long groupId, long parentCategoryId, 3139 java.lang.String name, long vocabularyId) { 3140 return getPersistence() 3141 .countByG_P_N_V(groupId, parentCategoryId, name, vocabularyId); 3142 } 3143 3144 /** 3145 * Returns the number of asset categories that the user has permission to view where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 3146 * 3147 * @param groupId the group ID 3148 * @param parentCategoryId the parent category ID 3149 * @param name the name 3150 * @param vocabularyId the vocabulary ID 3151 * @return the number of matching asset categories that the user has permission to view 3152 */ 3153 public static int filterCountByG_P_N_V(long groupId, long parentCategoryId, 3154 java.lang.String name, long vocabularyId) { 3155 return getPersistence() 3156 .filterCountByG_P_N_V(groupId, parentCategoryId, name, 3157 vocabularyId); 3158 } 3159 3160 /** 3161 * Caches the asset category in the entity cache if it is enabled. 3162 * 3163 * @param assetCategory the asset category 3164 */ 3165 public static void cacheResult(AssetCategory assetCategory) { 3166 getPersistence().cacheResult(assetCategory); 3167 } 3168 3169 /** 3170 * Caches the asset categories in the entity cache if it is enabled. 3171 * 3172 * @param assetCategories the asset categories 3173 */ 3174 public static void cacheResult(List<AssetCategory> assetCategories) { 3175 getPersistence().cacheResult(assetCategories); 3176 } 3177 3178 /** 3179 * Creates a new asset category with the primary key. Does not add the asset category to the database. 3180 * 3181 * @param categoryId the primary key for the new asset category 3182 * @return the new asset category 3183 */ 3184 public static AssetCategory create(long categoryId) { 3185 return getPersistence().create(categoryId); 3186 } 3187 3188 /** 3189 * Removes the asset category with the primary key from the database. Also notifies the appropriate model listeners. 3190 * 3191 * @param categoryId the primary key of the asset category 3192 * @return the asset category that was removed 3193 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 3194 */ 3195 public static AssetCategory remove(long categoryId) 3196 throws com.liferay.portlet.asset.NoSuchCategoryException { 3197 return getPersistence().remove(categoryId); 3198 } 3199 3200 public static AssetCategory updateImpl(AssetCategory assetCategory) { 3201 return getPersistence().updateImpl(assetCategory); 3202 } 3203 3204 /** 3205 * Returns the asset category with the primary key or throws a {@link NoSuchCategoryException} if it could not be found. 3206 * 3207 * @param categoryId the primary key of the asset category 3208 * @return the asset category 3209 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 3210 */ 3211 public static AssetCategory findByPrimaryKey(long categoryId) 3212 throws com.liferay.portlet.asset.NoSuchCategoryException { 3213 return getPersistence().findByPrimaryKey(categoryId); 3214 } 3215 3216 /** 3217 * Returns the asset category with the primary key or returns <code>null</code> if it could not be found. 3218 * 3219 * @param categoryId the primary key of the asset category 3220 * @return the asset category, or <code>null</code> if a asset category with the primary key could not be found 3221 */ 3222 public static AssetCategory fetchByPrimaryKey(long categoryId) { 3223 return getPersistence().fetchByPrimaryKey(categoryId); 3224 } 3225 3226 public static java.util.Map<java.io.Serializable, AssetCategory> fetchByPrimaryKeys( 3227 java.util.Set<java.io.Serializable> primaryKeys) { 3228 return getPersistence().fetchByPrimaryKeys(primaryKeys); 3229 } 3230 3231 /** 3232 * Returns all the asset categories. 3233 * 3234 * @return the asset categories 3235 */ 3236 public static List<AssetCategory> findAll() { 3237 return getPersistence().findAll(); 3238 } 3239 3240 /** 3241 * Returns a range of all the asset categories. 3242 * 3243 * <p> 3244 * 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. 3245 * </p> 3246 * 3247 * @param start the lower bound of the range of asset categories 3248 * @param end the upper bound of the range of asset categories (not inclusive) 3249 * @return the range of asset categories 3250 */ 3251 public static List<AssetCategory> findAll(int start, int end) { 3252 return getPersistence().findAll(start, end); 3253 } 3254 3255 /** 3256 * Returns an ordered range of all the asset categories. 3257 * 3258 * <p> 3259 * 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. 3260 * </p> 3261 * 3262 * @param start the lower bound of the range of asset categories 3263 * @param end the upper bound of the range of asset categories (not inclusive) 3264 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3265 * @return the ordered range of asset categories 3266 */ 3267 public static List<AssetCategory> findAll(int start, int end, 3268 OrderByComparator<AssetCategory> orderByComparator) { 3269 return getPersistence().findAll(start, end, orderByComparator); 3270 } 3271 3272 /** 3273 * Returns an ordered range of all the asset categories. 3274 * 3275 * <p> 3276 * 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. 3277 * </p> 3278 * 3279 * @param start the lower bound of the range of asset categories 3280 * @param end the upper bound of the range of asset categories (not inclusive) 3281 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3282 * @param retrieveFromCache whether to retrieve from the finder cache 3283 * @return the ordered range of asset categories 3284 */ 3285 public static List<AssetCategory> findAll(int start, int end, 3286 OrderByComparator<AssetCategory> orderByComparator, 3287 boolean retrieveFromCache) { 3288 return getPersistence() 3289 .findAll(start, end, orderByComparator, retrieveFromCache); 3290 } 3291 3292 /** 3293 * Removes all the asset categories from the database. 3294 */ 3295 public static void removeAll() { 3296 getPersistence().removeAll(); 3297 } 3298 3299 /** 3300 * Returns the number of asset categories. 3301 * 3302 * @return the number of asset categories 3303 */ 3304 public static int countAll() { 3305 return getPersistence().countAll(); 3306 } 3307 3308 /** 3309 * Returns the primaryKeys of asset entries associated with the asset category. 3310 * 3311 * @param pk the primary key of the asset category 3312 * @return long[] of the primaryKeys of asset entries associated with the asset category 3313 */ 3314 public static long[] getAssetEntryPrimaryKeys(long pk) { 3315 return getPersistence().getAssetEntryPrimaryKeys(pk); 3316 } 3317 3318 /** 3319 * Returns all the asset entries associated with the asset category. 3320 * 3321 * @param pk the primary key of the asset category 3322 * @return the asset entries associated with the asset category 3323 */ 3324 public static List<com.liferay.portlet.asset.model.AssetEntry> getAssetEntries( 3325 long pk) { 3326 return getPersistence().getAssetEntries(pk); 3327 } 3328 3329 /** 3330 * Returns a range of all the asset entries associated with the asset category. 3331 * 3332 * <p> 3333 * 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. 3334 * </p> 3335 * 3336 * @param pk the primary key of the asset category 3337 * @param start the lower bound of the range of asset categories 3338 * @param end the upper bound of the range of asset categories (not inclusive) 3339 * @return the range of asset entries associated with the asset category 3340 */ 3341 public static List<com.liferay.portlet.asset.model.AssetEntry> getAssetEntries( 3342 long pk, int start, int end) { 3343 return getPersistence().getAssetEntries(pk, start, end); 3344 } 3345 3346 /** 3347 * Returns an ordered range of all the asset entries associated with the asset category. 3348 * 3349 * <p> 3350 * 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. 3351 * </p> 3352 * 3353 * @param pk the primary key of the asset category 3354 * @param start the lower bound of the range of asset categories 3355 * @param end the upper bound of the range of asset categories (not inclusive) 3356 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3357 * @return the ordered range of asset entries associated with the asset category 3358 */ 3359 public static List<com.liferay.portlet.asset.model.AssetEntry> getAssetEntries( 3360 long pk, int start, int end, 3361 OrderByComparator<com.liferay.portlet.asset.model.AssetEntry> orderByComparator) { 3362 return getPersistence() 3363 .getAssetEntries(pk, start, end, orderByComparator); 3364 } 3365 3366 /** 3367 * Returns the number of asset entries associated with the asset category. 3368 * 3369 * @param pk the primary key of the asset category 3370 * @return the number of asset entries associated with the asset category 3371 */ 3372 public static int getAssetEntriesSize(long pk) { 3373 return getPersistence().getAssetEntriesSize(pk); 3374 } 3375 3376 /** 3377 * Returns <code>true</code> if the asset entry is associated with the asset category. 3378 * 3379 * @param pk the primary key of the asset category 3380 * @param assetEntryPK the primary key of the asset entry 3381 * @return <code>true</code> if the asset entry is associated with the asset category; <code>false</code> otherwise 3382 */ 3383 public static boolean containsAssetEntry(long pk, long assetEntryPK) { 3384 return getPersistence().containsAssetEntry(pk, assetEntryPK); 3385 } 3386 3387 /** 3388 * Returns <code>true</code> if the asset category has any asset entries associated with it. 3389 * 3390 * @param pk the primary key of the asset category to check for associations with asset entries 3391 * @return <code>true</code> if the asset category has any asset entries associated with it; <code>false</code> otherwise 3392 */ 3393 public static boolean containsAssetEntries(long pk) { 3394 return getPersistence().containsAssetEntries(pk); 3395 } 3396 3397 /** 3398 * Adds an association between the asset category and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3399 * 3400 * @param pk the primary key of the asset category 3401 * @param assetEntryPK the primary key of the asset entry 3402 */ 3403 public static void addAssetEntry(long pk, long assetEntryPK) { 3404 getPersistence().addAssetEntry(pk, assetEntryPK); 3405 } 3406 3407 /** 3408 * Adds an association between the asset category and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3409 * 3410 * @param pk the primary key of the asset category 3411 * @param assetEntry the asset entry 3412 */ 3413 public static void addAssetEntry(long pk, 3414 com.liferay.portlet.asset.model.AssetEntry assetEntry) { 3415 getPersistence().addAssetEntry(pk, assetEntry); 3416 } 3417 3418 /** 3419 * Adds an association between the asset category and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3420 * 3421 * @param pk the primary key of the asset category 3422 * @param assetEntryPKs the primary keys of the asset entries 3423 */ 3424 public static void addAssetEntries(long pk, long[] assetEntryPKs) { 3425 getPersistence().addAssetEntries(pk, assetEntryPKs); 3426 } 3427 3428 /** 3429 * Adds an association between the asset category and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3430 * 3431 * @param pk the primary key of the asset category 3432 * @param assetEntries the asset entries 3433 */ 3434 public static void addAssetEntries(long pk, 3435 List<com.liferay.portlet.asset.model.AssetEntry> assetEntries) { 3436 getPersistence().addAssetEntries(pk, assetEntries); 3437 } 3438 3439 /** 3440 * Clears all associations between the asset category and its asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3441 * 3442 * @param pk the primary key of the asset category to clear the associated asset entries from 3443 */ 3444 public static void clearAssetEntries(long pk) { 3445 getPersistence().clearAssetEntries(pk); 3446 } 3447 3448 /** 3449 * Removes the association between the asset category and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3450 * 3451 * @param pk the primary key of the asset category 3452 * @param assetEntryPK the primary key of the asset entry 3453 */ 3454 public static void removeAssetEntry(long pk, long assetEntryPK) { 3455 getPersistence().removeAssetEntry(pk, assetEntryPK); 3456 } 3457 3458 /** 3459 * Removes the association between the asset category and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3460 * 3461 * @param pk the primary key of the asset category 3462 * @param assetEntry the asset entry 3463 */ 3464 public static void removeAssetEntry(long pk, 3465 com.liferay.portlet.asset.model.AssetEntry assetEntry) { 3466 getPersistence().removeAssetEntry(pk, assetEntry); 3467 } 3468 3469 /** 3470 * Removes the association between the asset category and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3471 * 3472 * @param pk the primary key of the asset category 3473 * @param assetEntryPKs the primary keys of the asset entries 3474 */ 3475 public static void removeAssetEntries(long pk, long[] assetEntryPKs) { 3476 getPersistence().removeAssetEntries(pk, assetEntryPKs); 3477 } 3478 3479 /** 3480 * Removes the association between the asset category and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3481 * 3482 * @param pk the primary key of the asset category 3483 * @param assetEntries the asset entries 3484 */ 3485 public static void removeAssetEntries(long pk, 3486 List<com.liferay.portlet.asset.model.AssetEntry> assetEntries) { 3487 getPersistence().removeAssetEntries(pk, assetEntries); 3488 } 3489 3490 /** 3491 * 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. 3492 * 3493 * @param pk the primary key of the asset category 3494 * @param assetEntryPKs the primary keys of the asset entries to be associated with the asset category 3495 */ 3496 public static void setAssetEntries(long pk, long[] assetEntryPKs) { 3497 getPersistence().setAssetEntries(pk, assetEntryPKs); 3498 } 3499 3500 /** 3501 * 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. 3502 * 3503 * @param pk the primary key of the asset category 3504 * @param assetEntries the asset entries to be associated with the asset category 3505 */ 3506 public static void setAssetEntries(long pk, 3507 List<com.liferay.portlet.asset.model.AssetEntry> assetEntries) { 3508 getPersistence().setAssetEntries(pk, assetEntries); 3509 } 3510 3511 public static java.util.Set<java.lang.String> getBadColumnNames() { 3512 return getPersistence().getBadColumnNames(); 3513 } 3514 3515 public static long countAncestors(AssetCategory assetCategory) { 3516 return getPersistence().countAncestors(assetCategory); 3517 } 3518 3519 public static long countDescendants(AssetCategory assetCategory) { 3520 return getPersistence().countDescendants(assetCategory); 3521 } 3522 3523 public static List<AssetCategory> getAncestors(AssetCategory assetCategory) { 3524 return getPersistence().getAncestors(assetCategory); 3525 } 3526 3527 public static List<AssetCategory> getDescendants( 3528 AssetCategory assetCategory) { 3529 return getPersistence().getDescendants(assetCategory); 3530 } 3531 3532 /** 3533 * Rebuilds the asset categories tree for the scope using the modified pre-order tree traversal algorithm. 3534 * 3535 * <p> 3536 * 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. 3537 * </p> 3538 * 3539 * @param groupId the ID of the scope 3540 * @param force whether to force the rebuild even if the tree is not stale 3541 */ 3542 public static void rebuildTree(long groupId, boolean force) { 3543 getPersistence().rebuildTree(groupId, force); 3544 } 3545 3546 public static void setRebuildTreeEnabled(boolean rebuildTreeEnabled) { 3547 getPersistence().setRebuildTreeEnabled(rebuildTreeEnabled); 3548 } 3549 3550 public static AssetCategoryPersistence getPersistence() { 3551 if (_persistence == null) { 3552 _persistence = (AssetCategoryPersistence)PortalBeanLocatorUtil.locate(AssetCategoryPersistence.class.getName()); 3553 3554 ReferenceRegistry.registerReference(AssetCategoryUtil.class, 3555 "_persistence"); 3556 } 3557 3558 return _persistence; 3559 } 3560 3561 /** 3562 * @deprecated As of 6.2.0 3563 */ 3564 @Deprecated 3565 public void setPersistence(AssetCategoryPersistence persistence) { 3566 } 3567 3568 private static AssetCategoryPersistence _persistence; 3569 }