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