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