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