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