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 * Removes all the asset categories where groupId = ? and vocabularyId = ? from the database. 1337 * 1338 * @param groupId the group ID 1339 * @param vocabularyId the vocabulary ID 1340 * @throws SystemException if a system exception occurred 1341 */ 1342 public static void removeByG_V(long groupId, long vocabularyId) 1343 throws com.liferay.portal.kernel.exception.SystemException { 1344 getPersistence().removeByG_V(groupId, vocabularyId); 1345 } 1346 1347 /** 1348 * Returns the number of asset categories where groupId = ? and vocabularyId = ?. 1349 * 1350 * @param groupId the group ID 1351 * @param vocabularyId the vocabulary ID 1352 * @return the number of matching asset categories 1353 * @throws SystemException if a system exception occurred 1354 */ 1355 public static int countByG_V(long groupId, long vocabularyId) 1356 throws com.liferay.portal.kernel.exception.SystemException { 1357 return getPersistence().countByG_V(groupId, vocabularyId); 1358 } 1359 1360 /** 1361 * Returns the number of asset categories that the user has permission to view where groupId = ? and vocabularyId = ?. 1362 * 1363 * @param groupId the group ID 1364 * @param vocabularyId the vocabulary ID 1365 * @return the number of matching asset categories that the user has permission to view 1366 * @throws SystemException if a system exception occurred 1367 */ 1368 public static int filterCountByG_V(long groupId, long vocabularyId) 1369 throws com.liferay.portal.kernel.exception.SystemException { 1370 return getPersistence().filterCountByG_V(groupId, vocabularyId); 1371 } 1372 1373 /** 1374 * Returns all the asset categories where parentCategoryId = ? and name = ?. 1375 * 1376 * @param parentCategoryId the parent category ID 1377 * @param name the name 1378 * @return the matching asset categories 1379 * @throws SystemException if a system exception occurred 1380 */ 1381 public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByP_N( 1382 long parentCategoryId, java.lang.String name) 1383 throws com.liferay.portal.kernel.exception.SystemException { 1384 return getPersistence().findByP_N(parentCategoryId, name); 1385 } 1386 1387 /** 1388 * Returns a range of all the asset categories where parentCategoryId = ? and name = ?. 1389 * 1390 * <p> 1391 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1392 * </p> 1393 * 1394 * @param parentCategoryId the parent category ID 1395 * @param name the name 1396 * @param start the lower bound of the range of asset categories 1397 * @param end the upper bound of the range of asset categories (not inclusive) 1398 * @return the range of matching asset categories 1399 * @throws SystemException if a system exception occurred 1400 */ 1401 public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByP_N( 1402 long parentCategoryId, java.lang.String name, int start, int end) 1403 throws com.liferay.portal.kernel.exception.SystemException { 1404 return getPersistence().findByP_N(parentCategoryId, name, start, end); 1405 } 1406 1407 /** 1408 * Returns an ordered range of all the asset categories where parentCategoryId = ? and name = ?. 1409 * 1410 * <p> 1411 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1412 * </p> 1413 * 1414 * @param parentCategoryId the parent category ID 1415 * @param name the name 1416 * @param start the lower bound of the range of asset categories 1417 * @param end the upper bound of the range of asset categories (not inclusive) 1418 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1419 * @return the ordered range of matching asset categories 1420 * @throws SystemException if a system exception occurred 1421 */ 1422 public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByP_N( 1423 long parentCategoryId, java.lang.String name, int start, int end, 1424 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1425 throws com.liferay.portal.kernel.exception.SystemException { 1426 return getPersistence() 1427 .findByP_N(parentCategoryId, name, start, end, 1428 orderByComparator); 1429 } 1430 1431 /** 1432 * Returns the first asset category in the ordered set where parentCategoryId = ? and name = ?. 1433 * 1434 * @param parentCategoryId the parent category ID 1435 * @param name the name 1436 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1437 * @return the first matching asset category 1438 * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found 1439 * @throws SystemException if a system exception occurred 1440 */ 1441 public static com.liferay.portlet.asset.model.AssetCategory findByP_N_First( 1442 long parentCategoryId, java.lang.String name, 1443 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1444 throws com.liferay.portal.kernel.exception.SystemException, 1445 com.liferay.portlet.asset.NoSuchCategoryException { 1446 return getPersistence() 1447 .findByP_N_First(parentCategoryId, name, orderByComparator); 1448 } 1449 1450 /** 1451 * Returns the first asset category in the ordered set where parentCategoryId = ? and name = ?. 1452 * 1453 * @param parentCategoryId the parent category ID 1454 * @param name the name 1455 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1456 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 1457 * @throws SystemException if a system exception occurred 1458 */ 1459 public static com.liferay.portlet.asset.model.AssetCategory fetchByP_N_First( 1460 long parentCategoryId, java.lang.String name, 1461 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1462 throws com.liferay.portal.kernel.exception.SystemException { 1463 return getPersistence() 1464 .fetchByP_N_First(parentCategoryId, name, orderByComparator); 1465 } 1466 1467 /** 1468 * Returns the last asset category in the ordered set where parentCategoryId = ? and name = ?. 1469 * 1470 * @param parentCategoryId the parent category ID 1471 * @param name the name 1472 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1473 * @return the last matching asset category 1474 * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found 1475 * @throws SystemException if a system exception occurred 1476 */ 1477 public static com.liferay.portlet.asset.model.AssetCategory findByP_N_Last( 1478 long parentCategoryId, java.lang.String name, 1479 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1480 throws com.liferay.portal.kernel.exception.SystemException, 1481 com.liferay.portlet.asset.NoSuchCategoryException { 1482 return getPersistence() 1483 .findByP_N_Last(parentCategoryId, name, orderByComparator); 1484 } 1485 1486 /** 1487 * Returns the last asset category in the ordered set where parentCategoryId = ? and name = ?. 1488 * 1489 * @param parentCategoryId the parent category ID 1490 * @param name the name 1491 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1492 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 1493 * @throws SystemException if a system exception occurred 1494 */ 1495 public static com.liferay.portlet.asset.model.AssetCategory fetchByP_N_Last( 1496 long parentCategoryId, java.lang.String name, 1497 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1498 throws com.liferay.portal.kernel.exception.SystemException { 1499 return getPersistence() 1500 .fetchByP_N_Last(parentCategoryId, name, orderByComparator); 1501 } 1502 1503 /** 1504 * Returns the asset categories before and after the current asset category in the ordered set where parentCategoryId = ? and name = ?. 1505 * 1506 * @param categoryId the primary key of the current asset category 1507 * @param parentCategoryId the parent category ID 1508 * @param name the name 1509 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1510 * @return the previous, current, and next asset category 1511 * @throws com.liferay.portlet.asset.NoSuchCategoryException if a asset category with the primary key could not be found 1512 * @throws SystemException if a system exception occurred 1513 */ 1514 public static com.liferay.portlet.asset.model.AssetCategory[] findByP_N_PrevAndNext( 1515 long categoryId, long parentCategoryId, java.lang.String name, 1516 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1517 throws com.liferay.portal.kernel.exception.SystemException, 1518 com.liferay.portlet.asset.NoSuchCategoryException { 1519 return getPersistence() 1520 .findByP_N_PrevAndNext(categoryId, parentCategoryId, name, 1521 orderByComparator); 1522 } 1523 1524 /** 1525 * Removes all the asset categories where parentCategoryId = ? and name = ? from the database. 1526 * 1527 * @param parentCategoryId the parent category ID 1528 * @param name the name 1529 * @throws SystemException if a system exception occurred 1530 */ 1531 public static void removeByP_N(long parentCategoryId, java.lang.String name) 1532 throws com.liferay.portal.kernel.exception.SystemException { 1533 getPersistence().removeByP_N(parentCategoryId, name); 1534 } 1535 1536 /** 1537 * Returns the number of asset categories where parentCategoryId = ? and name = ?. 1538 * 1539 * @param parentCategoryId the parent category ID 1540 * @param name the name 1541 * @return the number of matching asset categories 1542 * @throws SystemException if a system exception occurred 1543 */ 1544 public static int countByP_N(long parentCategoryId, java.lang.String name) 1545 throws com.liferay.portal.kernel.exception.SystemException { 1546 return getPersistence().countByP_N(parentCategoryId, name); 1547 } 1548 1549 /** 1550 * Returns all the asset categories where parentCategoryId = ? and vocabularyId = ?. 1551 * 1552 * @param parentCategoryId the parent category ID 1553 * @param vocabularyId the vocabulary ID 1554 * @return the matching asset categories 1555 * @throws SystemException if a system exception occurred 1556 */ 1557 public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByP_V( 1558 long parentCategoryId, long vocabularyId) 1559 throws com.liferay.portal.kernel.exception.SystemException { 1560 return getPersistence().findByP_V(parentCategoryId, vocabularyId); 1561 } 1562 1563 /** 1564 * Returns a range of all the asset categories where parentCategoryId = ? and vocabularyId = ?. 1565 * 1566 * <p> 1567 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1568 * </p> 1569 * 1570 * @param parentCategoryId the parent category ID 1571 * @param vocabularyId the vocabulary ID 1572 * @param start the lower bound of the range of asset categories 1573 * @param end the upper bound of the range of asset categories (not inclusive) 1574 * @return the range of matching asset categories 1575 * @throws SystemException if a system exception occurred 1576 */ 1577 public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByP_V( 1578 long parentCategoryId, long vocabularyId, int start, int end) 1579 throws com.liferay.portal.kernel.exception.SystemException { 1580 return getPersistence() 1581 .findByP_V(parentCategoryId, vocabularyId, start, end); 1582 } 1583 1584 /** 1585 * Returns an ordered range of all the asset categories where parentCategoryId = ? and vocabularyId = ?. 1586 * 1587 * <p> 1588 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1589 * </p> 1590 * 1591 * @param parentCategoryId the parent category ID 1592 * @param vocabularyId the vocabulary ID 1593 * @param start the lower bound of the range of asset categories 1594 * @param end the upper bound of the range of asset categories (not inclusive) 1595 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1596 * @return the ordered range of matching asset categories 1597 * @throws SystemException if a system exception occurred 1598 */ 1599 public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByP_V( 1600 long parentCategoryId, long vocabularyId, int start, int end, 1601 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1602 throws com.liferay.portal.kernel.exception.SystemException { 1603 return getPersistence() 1604 .findByP_V(parentCategoryId, vocabularyId, start, end, 1605 orderByComparator); 1606 } 1607 1608 /** 1609 * Returns the first asset category in the ordered set where parentCategoryId = ? and vocabularyId = ?. 1610 * 1611 * @param parentCategoryId the parent category ID 1612 * @param vocabularyId the vocabulary ID 1613 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1614 * @return the first matching asset category 1615 * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found 1616 * @throws SystemException if a system exception occurred 1617 */ 1618 public static com.liferay.portlet.asset.model.AssetCategory findByP_V_First( 1619 long parentCategoryId, long vocabularyId, 1620 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1621 throws com.liferay.portal.kernel.exception.SystemException, 1622 com.liferay.portlet.asset.NoSuchCategoryException { 1623 return getPersistence() 1624 .findByP_V_First(parentCategoryId, vocabularyId, 1625 orderByComparator); 1626 } 1627 1628 /** 1629 * Returns the first asset category in the ordered set where parentCategoryId = ? and vocabularyId = ?. 1630 * 1631 * @param parentCategoryId the parent category ID 1632 * @param vocabularyId the vocabulary ID 1633 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1634 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 1635 * @throws SystemException if a system exception occurred 1636 */ 1637 public static com.liferay.portlet.asset.model.AssetCategory fetchByP_V_First( 1638 long parentCategoryId, long vocabularyId, 1639 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1640 throws com.liferay.portal.kernel.exception.SystemException { 1641 return getPersistence() 1642 .fetchByP_V_First(parentCategoryId, vocabularyId, 1643 orderByComparator); 1644 } 1645 1646 /** 1647 * Returns the last asset category in the ordered set where parentCategoryId = ? and vocabularyId = ?. 1648 * 1649 * @param parentCategoryId the parent category ID 1650 * @param vocabularyId the vocabulary ID 1651 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1652 * @return the last matching asset category 1653 * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found 1654 * @throws SystemException if a system exception occurred 1655 */ 1656 public static com.liferay.portlet.asset.model.AssetCategory findByP_V_Last( 1657 long parentCategoryId, long vocabularyId, 1658 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1659 throws com.liferay.portal.kernel.exception.SystemException, 1660 com.liferay.portlet.asset.NoSuchCategoryException { 1661 return getPersistence() 1662 .findByP_V_Last(parentCategoryId, vocabularyId, 1663 orderByComparator); 1664 } 1665 1666 /** 1667 * Returns the last asset category in the ordered set where parentCategoryId = ? and vocabularyId = ?. 1668 * 1669 * @param parentCategoryId the parent category ID 1670 * @param vocabularyId the vocabulary ID 1671 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1672 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 1673 * @throws SystemException if a system exception occurred 1674 */ 1675 public static com.liferay.portlet.asset.model.AssetCategory fetchByP_V_Last( 1676 long parentCategoryId, long vocabularyId, 1677 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1678 throws com.liferay.portal.kernel.exception.SystemException { 1679 return getPersistence() 1680 .fetchByP_V_Last(parentCategoryId, vocabularyId, 1681 orderByComparator); 1682 } 1683 1684 /** 1685 * Returns the asset categories before and after the current asset category in the ordered set where parentCategoryId = ? and vocabularyId = ?. 1686 * 1687 * @param categoryId the primary key of the current asset category 1688 * @param parentCategoryId the parent category ID 1689 * @param vocabularyId the vocabulary ID 1690 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1691 * @return the previous, current, and next asset category 1692 * @throws com.liferay.portlet.asset.NoSuchCategoryException if a asset category with the primary key could not be found 1693 * @throws SystemException if a system exception occurred 1694 */ 1695 public static com.liferay.portlet.asset.model.AssetCategory[] findByP_V_PrevAndNext( 1696 long categoryId, long parentCategoryId, long vocabularyId, 1697 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1698 throws com.liferay.portal.kernel.exception.SystemException, 1699 com.liferay.portlet.asset.NoSuchCategoryException { 1700 return getPersistence() 1701 .findByP_V_PrevAndNext(categoryId, parentCategoryId, 1702 vocabularyId, orderByComparator); 1703 } 1704 1705 /** 1706 * Removes all the asset categories where parentCategoryId = ? and vocabularyId = ? from the database. 1707 * 1708 * @param parentCategoryId the parent category ID 1709 * @param vocabularyId the vocabulary ID 1710 * @throws SystemException if a system exception occurred 1711 */ 1712 public static void removeByP_V(long parentCategoryId, long vocabularyId) 1713 throws com.liferay.portal.kernel.exception.SystemException { 1714 getPersistence().removeByP_V(parentCategoryId, vocabularyId); 1715 } 1716 1717 /** 1718 * Returns the number of asset categories where parentCategoryId = ? and vocabularyId = ?. 1719 * 1720 * @param parentCategoryId the parent category ID 1721 * @param vocabularyId the vocabulary ID 1722 * @return the number of matching asset categories 1723 * @throws SystemException if a system exception occurred 1724 */ 1725 public static int countByP_V(long parentCategoryId, long vocabularyId) 1726 throws com.liferay.portal.kernel.exception.SystemException { 1727 return getPersistence().countByP_V(parentCategoryId, vocabularyId); 1728 } 1729 1730 /** 1731 * Returns all the asset categories where name = ? and vocabularyId = ?. 1732 * 1733 * @param name the name 1734 * @param vocabularyId the vocabulary ID 1735 * @return the matching asset categories 1736 * @throws SystemException if a system exception occurred 1737 */ 1738 public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByN_V( 1739 java.lang.String name, long vocabularyId) 1740 throws com.liferay.portal.kernel.exception.SystemException { 1741 return getPersistence().findByN_V(name, vocabularyId); 1742 } 1743 1744 /** 1745 * Returns a range of all the asset categories where name = ? and vocabularyId = ?. 1746 * 1747 * <p> 1748 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1749 * </p> 1750 * 1751 * @param name the name 1752 * @param vocabularyId the vocabulary ID 1753 * @param start the lower bound of the range of asset categories 1754 * @param end the upper bound of the range of asset categories (not inclusive) 1755 * @return the range of matching asset categories 1756 * @throws SystemException if a system exception occurred 1757 */ 1758 public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByN_V( 1759 java.lang.String name, long vocabularyId, int start, int end) 1760 throws com.liferay.portal.kernel.exception.SystemException { 1761 return getPersistence().findByN_V(name, vocabularyId, start, end); 1762 } 1763 1764 /** 1765 * Returns an ordered range of all the asset categories where name = ? and vocabularyId = ?. 1766 * 1767 * <p> 1768 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 1769 * </p> 1770 * 1771 * @param name the name 1772 * @param vocabularyId the vocabulary ID 1773 * @param start the lower bound of the range of asset categories 1774 * @param end the upper bound of the range of asset categories (not inclusive) 1775 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1776 * @return the ordered range of matching asset categories 1777 * @throws SystemException if a system exception occurred 1778 */ 1779 public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByN_V( 1780 java.lang.String name, long vocabularyId, int start, int end, 1781 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1782 throws com.liferay.portal.kernel.exception.SystemException { 1783 return getPersistence() 1784 .findByN_V(name, vocabularyId, start, end, orderByComparator); 1785 } 1786 1787 /** 1788 * Returns the first asset category in the ordered set where name = ? and vocabularyId = ?. 1789 * 1790 * @param name the name 1791 * @param vocabularyId the vocabulary ID 1792 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1793 * @return the first matching asset category 1794 * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found 1795 * @throws SystemException if a system exception occurred 1796 */ 1797 public static com.liferay.portlet.asset.model.AssetCategory findByN_V_First( 1798 java.lang.String name, long vocabularyId, 1799 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1800 throws com.liferay.portal.kernel.exception.SystemException, 1801 com.liferay.portlet.asset.NoSuchCategoryException { 1802 return getPersistence() 1803 .findByN_V_First(name, vocabularyId, orderByComparator); 1804 } 1805 1806 /** 1807 * Returns the first asset category in the ordered set where name = ? and vocabularyId = ?. 1808 * 1809 * @param name the name 1810 * @param vocabularyId the vocabulary ID 1811 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1812 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 1813 * @throws SystemException if a system exception occurred 1814 */ 1815 public static com.liferay.portlet.asset.model.AssetCategory fetchByN_V_First( 1816 java.lang.String name, long vocabularyId, 1817 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1818 throws com.liferay.portal.kernel.exception.SystemException { 1819 return getPersistence() 1820 .fetchByN_V_First(name, vocabularyId, orderByComparator); 1821 } 1822 1823 /** 1824 * Returns the last asset category in the ordered set where name = ? and vocabularyId = ?. 1825 * 1826 * @param name the name 1827 * @param vocabularyId the vocabulary ID 1828 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1829 * @return the last matching asset category 1830 * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found 1831 * @throws SystemException if a system exception occurred 1832 */ 1833 public static com.liferay.portlet.asset.model.AssetCategory findByN_V_Last( 1834 java.lang.String name, long vocabularyId, 1835 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1836 throws com.liferay.portal.kernel.exception.SystemException, 1837 com.liferay.portlet.asset.NoSuchCategoryException { 1838 return getPersistence() 1839 .findByN_V_Last(name, vocabularyId, orderByComparator); 1840 } 1841 1842 /** 1843 * Returns the last asset category in the ordered set where name = ? and vocabularyId = ?. 1844 * 1845 * @param name the name 1846 * @param vocabularyId the vocabulary ID 1847 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1848 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 1849 * @throws SystemException if a system exception occurred 1850 */ 1851 public static com.liferay.portlet.asset.model.AssetCategory fetchByN_V_Last( 1852 java.lang.String name, long vocabularyId, 1853 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1854 throws com.liferay.portal.kernel.exception.SystemException { 1855 return getPersistence() 1856 .fetchByN_V_Last(name, vocabularyId, orderByComparator); 1857 } 1858 1859 /** 1860 * Returns the asset categories before and after the current asset category in the ordered set where name = ? and vocabularyId = ?. 1861 * 1862 * @param categoryId the primary key of the current asset category 1863 * @param name the name 1864 * @param vocabularyId the vocabulary ID 1865 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1866 * @return the previous, current, and next asset category 1867 * @throws com.liferay.portlet.asset.NoSuchCategoryException if a asset category with the primary key could not be found 1868 * @throws SystemException if a system exception occurred 1869 */ 1870 public static com.liferay.portlet.asset.model.AssetCategory[] findByN_V_PrevAndNext( 1871 long categoryId, java.lang.String name, long vocabularyId, 1872 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1873 throws com.liferay.portal.kernel.exception.SystemException, 1874 com.liferay.portlet.asset.NoSuchCategoryException { 1875 return getPersistence() 1876 .findByN_V_PrevAndNext(categoryId, name, vocabularyId, 1877 orderByComparator); 1878 } 1879 1880 /** 1881 * Removes all the asset categories where name = ? and vocabularyId = ? from the database. 1882 * 1883 * @param name the name 1884 * @param vocabularyId the vocabulary ID 1885 * @throws SystemException if a system exception occurred 1886 */ 1887 public static void removeByN_V(java.lang.String name, long vocabularyId) 1888 throws com.liferay.portal.kernel.exception.SystemException { 1889 getPersistence().removeByN_V(name, vocabularyId); 1890 } 1891 1892 /** 1893 * Returns the number of asset categories where name = ? and vocabularyId = ?. 1894 * 1895 * @param name the name 1896 * @param vocabularyId the vocabulary ID 1897 * @return the number of matching asset categories 1898 * @throws SystemException if a system exception occurred 1899 */ 1900 public static int countByN_V(java.lang.String name, long vocabularyId) 1901 throws com.liferay.portal.kernel.exception.SystemException { 1902 return getPersistence().countByN_V(name, vocabularyId); 1903 } 1904 1905 /** 1906 * 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. 1907 * 1908 * @param parentCategoryId the parent category ID 1909 * @param name the name 1910 * @param vocabularyId the vocabulary ID 1911 * @return the matching asset category 1912 * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found 1913 * @throws SystemException if a system exception occurred 1914 */ 1915 public static com.liferay.portlet.asset.model.AssetCategory findByP_N_V( 1916 long parentCategoryId, java.lang.String name, long vocabularyId) 1917 throws com.liferay.portal.kernel.exception.SystemException, 1918 com.liferay.portlet.asset.NoSuchCategoryException { 1919 return getPersistence().findByP_N_V(parentCategoryId, name, vocabularyId); 1920 } 1921 1922 /** 1923 * 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. 1924 * 1925 * @param parentCategoryId the parent category ID 1926 * @param name the name 1927 * @param vocabularyId the vocabulary ID 1928 * @return the matching asset category, or <code>null</code> if a matching asset category could not be found 1929 * @throws SystemException if a system exception occurred 1930 */ 1931 public static com.liferay.portlet.asset.model.AssetCategory fetchByP_N_V( 1932 long parentCategoryId, java.lang.String name, long vocabularyId) 1933 throws com.liferay.portal.kernel.exception.SystemException { 1934 return getPersistence() 1935 .fetchByP_N_V(parentCategoryId, name, vocabularyId); 1936 } 1937 1938 /** 1939 * 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. 1940 * 1941 * @param parentCategoryId the parent category ID 1942 * @param name the name 1943 * @param vocabularyId the vocabulary ID 1944 * @param retrieveFromCache whether to use the finder cache 1945 * @return the matching asset category, or <code>null</code> if a matching asset category could not be found 1946 * @throws SystemException if a system exception occurred 1947 */ 1948 public static com.liferay.portlet.asset.model.AssetCategory fetchByP_N_V( 1949 long parentCategoryId, java.lang.String name, long vocabularyId, 1950 boolean retrieveFromCache) 1951 throws com.liferay.portal.kernel.exception.SystemException { 1952 return getPersistence() 1953 .fetchByP_N_V(parentCategoryId, name, vocabularyId, 1954 retrieveFromCache); 1955 } 1956 1957 /** 1958 * Removes the asset category where parentCategoryId = ? and name = ? and vocabularyId = ? from the database. 1959 * 1960 * @param parentCategoryId the parent category ID 1961 * @param name the name 1962 * @param vocabularyId the vocabulary ID 1963 * @return the asset category that was removed 1964 * @throws SystemException if a system exception occurred 1965 */ 1966 public static com.liferay.portlet.asset.model.AssetCategory removeByP_N_V( 1967 long parentCategoryId, java.lang.String name, long vocabularyId) 1968 throws com.liferay.portal.kernel.exception.SystemException, 1969 com.liferay.portlet.asset.NoSuchCategoryException { 1970 return getPersistence() 1971 .removeByP_N_V(parentCategoryId, name, vocabularyId); 1972 } 1973 1974 /** 1975 * Returns the number of asset categories where parentCategoryId = ? and name = ? and vocabularyId = ?. 1976 * 1977 * @param parentCategoryId the parent category ID 1978 * @param name the name 1979 * @param vocabularyId the vocabulary ID 1980 * @return the number of matching asset categories 1981 * @throws SystemException if a system exception occurred 1982 */ 1983 public static int countByP_N_V(long parentCategoryId, 1984 java.lang.String name, long vocabularyId) 1985 throws com.liferay.portal.kernel.exception.SystemException { 1986 return getPersistence() 1987 .countByP_N_V(parentCategoryId, name, vocabularyId); 1988 } 1989 1990 /** 1991 * Returns all the asset categories where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 1992 * 1993 * @param groupId the group ID 1994 * @param parentCategoryId the parent category ID 1995 * @param name the name 1996 * @param vocabularyId the vocabulary ID 1997 * @return the matching asset categories 1998 * @throws SystemException if a system exception occurred 1999 */ 2000 public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByG_P_N_V( 2001 long groupId, long parentCategoryId, java.lang.String name, 2002 long vocabularyId) 2003 throws com.liferay.portal.kernel.exception.SystemException { 2004 return getPersistence() 2005 .findByG_P_N_V(groupId, parentCategoryId, name, vocabularyId); 2006 } 2007 2008 /** 2009 * Returns a range of all the asset categories where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2010 * 2011 * <p> 2012 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2013 * </p> 2014 * 2015 * @param groupId the group ID 2016 * @param parentCategoryId the parent category ID 2017 * @param name the name 2018 * @param vocabularyId the vocabulary ID 2019 * @param start the lower bound of the range of asset categories 2020 * @param end the upper bound of the range of asset categories (not inclusive) 2021 * @return the range of matching asset categories 2022 * @throws SystemException if a system exception occurred 2023 */ 2024 public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByG_P_N_V( 2025 long groupId, long parentCategoryId, java.lang.String name, 2026 long vocabularyId, int start, int end) 2027 throws com.liferay.portal.kernel.exception.SystemException { 2028 return getPersistence() 2029 .findByG_P_N_V(groupId, parentCategoryId, name, 2030 vocabularyId, start, end); 2031 } 2032 2033 /** 2034 * Returns an ordered range of all the asset categories where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2035 * 2036 * <p> 2037 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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. 2038 * </p> 2039 * 2040 * @param groupId the group ID 2041 * @param parentCategoryId the parent category ID 2042 * @param name the name 2043 * @param vocabularyId the vocabulary ID 2044 * @param start the lower bound of the range of asset categories 2045 * @param end the upper bound of the range of asset categories (not inclusive) 2046 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2047 * @return the ordered range of matching asset categories 2048 * @throws SystemException if a system exception occurred 2049 */ 2050 public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findByG_P_N_V( 2051 long groupId, long parentCategoryId, java.lang.String name, 2052 long vocabularyId, int start, int end, 2053 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2054 throws com.liferay.portal.kernel.exception.SystemException { 2055 return getPersistence() 2056 .findByG_P_N_V(groupId, parentCategoryId, name, 2057 vocabularyId, start, end, orderByComparator); 2058 } 2059 2060 /** 2061 * Returns the first asset category in the ordered set where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2062 * 2063 * @param groupId the group ID 2064 * @param parentCategoryId the parent category ID 2065 * @param name the name 2066 * @param vocabularyId the vocabulary ID 2067 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2068 * @return the first matching asset category 2069 * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found 2070 * @throws SystemException if a system exception occurred 2071 */ 2072 public static com.liferay.portlet.asset.model.AssetCategory findByG_P_N_V_First( 2073 long groupId, long parentCategoryId, java.lang.String name, 2074 long vocabularyId, 2075 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2076 throws com.liferay.portal.kernel.exception.SystemException, 2077 com.liferay.portlet.asset.NoSuchCategoryException { 2078 return getPersistence() 2079 .findByG_P_N_V_First(groupId, parentCategoryId, name, 2080 vocabularyId, orderByComparator); 2081 } 2082 2083 /** 2084 * Returns the first asset category in the ordered set where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2085 * 2086 * @param groupId the group ID 2087 * @param parentCategoryId the parent category ID 2088 * @param name the name 2089 * @param vocabularyId the vocabulary ID 2090 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2091 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 2092 * @throws SystemException if a system exception occurred 2093 */ 2094 public static com.liferay.portlet.asset.model.AssetCategory fetchByG_P_N_V_First( 2095 long groupId, long parentCategoryId, java.lang.String name, 2096 long vocabularyId, 2097 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2098 throws com.liferay.portal.kernel.exception.SystemException { 2099 return getPersistence() 2100 .fetchByG_P_N_V_First(groupId, parentCategoryId, name, 2101 vocabularyId, orderByComparator); 2102 } 2103 2104 /** 2105 * Returns the last asset category in the ordered set where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2106 * 2107 * @param groupId the group ID 2108 * @param parentCategoryId the parent category ID 2109 * @param name the name 2110 * @param vocabularyId the vocabulary ID 2111 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2112 * @return the last matching asset category 2113 * @throws com.liferay.portlet.asset.NoSuchCategoryException if a matching asset category could not be found 2114 * @throws SystemException if a system exception occurred 2115 */ 2116 public static com.liferay.portlet.asset.model.AssetCategory findByG_P_N_V_Last( 2117 long groupId, long parentCategoryId, java.lang.String name, 2118 long vocabularyId, 2119 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2120 throws com.liferay.portal.kernel.exception.SystemException, 2121 com.liferay.portlet.asset.NoSuchCategoryException { 2122 return getPersistence() 2123 .findByG_P_N_V_Last(groupId, parentCategoryId, name, 2124 vocabularyId, orderByComparator); 2125 } 2126 2127 /** 2128 * Returns the last asset category in the ordered set where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2129 * 2130 * @param groupId the group ID 2131 * @param parentCategoryId the parent category ID 2132 * @param name the name 2133 * @param vocabularyId the vocabulary ID 2134 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2135 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 2136 * @throws SystemException if a system exception occurred 2137 */ 2138 public static com.liferay.portlet.asset.model.AssetCategory fetchByG_P_N_V_Last( 2139 long groupId, long parentCategoryId, java.lang.String name, 2140 long vocabularyId, 2141 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2142 throws com.liferay.portal.kernel.exception.SystemException { 2143 return getPersistence() 2144 .fetchByG_P_N_V_Last(groupId, parentCategoryId, name, 2145 vocabularyId, orderByComparator); 2146 } 2147 2148 /** 2149 * Returns the asset categories before and after the current asset category in the ordered set where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2150 * 2151 * @param categoryId the primary key of the current asset category 2152 * @param groupId the group ID 2153 * @param parentCategoryId the parent category ID 2154 * @param name the name 2155 * @param vocabularyId the vocabulary ID 2156 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2157 * @return the previous, current, and next asset category 2158 * @throws com.liferay.portlet.asset.NoSuchCategoryException if a asset category with the primary key could not be found 2159 * @throws SystemException if a system exception occurred 2160 */ 2161 public static com.liferay.portlet.asset.model.AssetCategory[] findByG_P_N_V_PrevAndNext( 2162 long categoryId, long groupId, long parentCategoryId, 2163 java.lang.String name, long vocabularyId, 2164 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2165 throws com.liferay.portal.kernel.exception.SystemException, 2166 com.liferay.portlet.asset.NoSuchCategoryException { 2167 return getPersistence() 2168 .findByG_P_N_V_PrevAndNext(categoryId, groupId, 2169 parentCategoryId, name, vocabularyId, orderByComparator); 2170 } 2171 2172 /** 2173 * Returns all the asset categories that the user has permission to view where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2174 * 2175 * @param groupId the group ID 2176 * @param parentCategoryId the parent category ID 2177 * @param name the name 2178 * @param vocabularyId the vocabulary ID 2179 * @return the matching asset categories that the user has permission to view 2180 * @throws SystemException if a system exception occurred 2181 */ 2182 public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> filterFindByG_P_N_V( 2183 long groupId, long parentCategoryId, java.lang.String name, 2184 long vocabularyId) 2185 throws com.liferay.portal.kernel.exception.SystemException { 2186 return getPersistence() 2187 .filterFindByG_P_N_V(groupId, parentCategoryId, name, 2188 vocabularyId); 2189 } 2190 2191 /** 2192 * Returns a range of all the asset categories that the user has permission to view where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2193 * 2194 * <p> 2195 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2196 * </p> 2197 * 2198 * @param groupId the group ID 2199 * @param parentCategoryId the parent category ID 2200 * @param name the name 2201 * @param vocabularyId the vocabulary ID 2202 * @param start the lower bound of the range of asset categories 2203 * @param end the upper bound of the range of asset categories (not inclusive) 2204 * @return the range of matching asset categories that the user has permission to view 2205 * @throws SystemException if a system exception occurred 2206 */ 2207 public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> filterFindByG_P_N_V( 2208 long groupId, long parentCategoryId, java.lang.String name, 2209 long vocabularyId, int start, int end) 2210 throws com.liferay.portal.kernel.exception.SystemException { 2211 return getPersistence() 2212 .filterFindByG_P_N_V(groupId, parentCategoryId, name, 2213 vocabularyId, start, end); 2214 } 2215 2216 /** 2217 * Returns an ordered range of all the asset categories that the user has permissions to view where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2218 * 2219 * <p> 2220 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2221 * </p> 2222 * 2223 * @param groupId the group ID 2224 * @param parentCategoryId the parent category ID 2225 * @param name the name 2226 * @param vocabularyId the vocabulary ID 2227 * @param start the lower bound of the range of asset categories 2228 * @param end the upper bound of the range of asset categories (not inclusive) 2229 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2230 * @return the ordered range of matching asset categories that the user has permission to view 2231 * @throws SystemException if a system exception occurred 2232 */ 2233 public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> filterFindByG_P_N_V( 2234 long groupId, long parentCategoryId, java.lang.String name, 2235 long vocabularyId, int start, int end, 2236 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2237 throws com.liferay.portal.kernel.exception.SystemException { 2238 return getPersistence() 2239 .filterFindByG_P_N_V(groupId, parentCategoryId, name, 2240 vocabularyId, start, end, orderByComparator); 2241 } 2242 2243 /** 2244 * 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 = ?. 2245 * 2246 * @param categoryId the primary key of the current asset category 2247 * @param groupId the group ID 2248 * @param parentCategoryId the parent category ID 2249 * @param name the name 2250 * @param vocabularyId the vocabulary ID 2251 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2252 * @return the previous, current, and next asset category 2253 * @throws com.liferay.portlet.asset.NoSuchCategoryException if a asset category with the primary key could not be found 2254 * @throws SystemException if a system exception occurred 2255 */ 2256 public static com.liferay.portlet.asset.model.AssetCategory[] filterFindByG_P_N_V_PrevAndNext( 2257 long categoryId, long groupId, long parentCategoryId, 2258 java.lang.String name, long vocabularyId, 2259 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2260 throws com.liferay.portal.kernel.exception.SystemException, 2261 com.liferay.portlet.asset.NoSuchCategoryException { 2262 return getPersistence() 2263 .filterFindByG_P_N_V_PrevAndNext(categoryId, groupId, 2264 parentCategoryId, name, vocabularyId, orderByComparator); 2265 } 2266 2267 /** 2268 * Removes all the asset categories where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ? from the database. 2269 * 2270 * @param groupId the group ID 2271 * @param parentCategoryId the parent category ID 2272 * @param name the name 2273 * @param vocabularyId the vocabulary ID 2274 * @throws SystemException if a system exception occurred 2275 */ 2276 public static void removeByG_P_N_V(long groupId, long parentCategoryId, 2277 java.lang.String name, long vocabularyId) 2278 throws com.liferay.portal.kernel.exception.SystemException { 2279 getPersistence() 2280 .removeByG_P_N_V(groupId, parentCategoryId, name, vocabularyId); 2281 } 2282 2283 /** 2284 * Returns the number of asset categories where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2285 * 2286 * @param groupId the group ID 2287 * @param parentCategoryId the parent category ID 2288 * @param name the name 2289 * @param vocabularyId the vocabulary ID 2290 * @return the number of matching asset categories 2291 * @throws SystemException if a system exception occurred 2292 */ 2293 public static int countByG_P_N_V(long groupId, long parentCategoryId, 2294 java.lang.String name, long vocabularyId) 2295 throws com.liferay.portal.kernel.exception.SystemException { 2296 return getPersistence() 2297 .countByG_P_N_V(groupId, parentCategoryId, name, vocabularyId); 2298 } 2299 2300 /** 2301 * Returns the number of asset categories that the user has permission to view where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2302 * 2303 * @param groupId the group ID 2304 * @param parentCategoryId the parent category ID 2305 * @param name the name 2306 * @param vocabularyId the vocabulary ID 2307 * @return the number of matching asset categories that the user has permission to view 2308 * @throws SystemException if a system exception occurred 2309 */ 2310 public static int filterCountByG_P_N_V(long groupId, long parentCategoryId, 2311 java.lang.String name, long vocabularyId) 2312 throws com.liferay.portal.kernel.exception.SystemException { 2313 return getPersistence() 2314 .filterCountByG_P_N_V(groupId, parentCategoryId, name, 2315 vocabularyId); 2316 } 2317 2318 /** 2319 * Caches the asset category in the entity cache if it is enabled. 2320 * 2321 * @param assetCategory the asset category 2322 */ 2323 public static void cacheResult( 2324 com.liferay.portlet.asset.model.AssetCategory assetCategory) { 2325 getPersistence().cacheResult(assetCategory); 2326 } 2327 2328 /** 2329 * Caches the asset categories in the entity cache if it is enabled. 2330 * 2331 * @param assetCategories the asset categories 2332 */ 2333 public static void cacheResult( 2334 java.util.List<com.liferay.portlet.asset.model.AssetCategory> assetCategories) { 2335 getPersistence().cacheResult(assetCategories); 2336 } 2337 2338 /** 2339 * Creates a new asset category with the primary key. Does not add the asset category to the database. 2340 * 2341 * @param categoryId the primary key for the new asset category 2342 * @return the new asset category 2343 */ 2344 public static com.liferay.portlet.asset.model.AssetCategory create( 2345 long categoryId) { 2346 return getPersistence().create(categoryId); 2347 } 2348 2349 /** 2350 * Removes the asset category with the primary key from the database. Also notifies the appropriate model listeners. 2351 * 2352 * @param categoryId the primary key of the asset category 2353 * @return the asset category that was removed 2354 * @throws com.liferay.portlet.asset.NoSuchCategoryException if a asset category with the primary key could not be found 2355 * @throws SystemException if a system exception occurred 2356 */ 2357 public static com.liferay.portlet.asset.model.AssetCategory remove( 2358 long categoryId) 2359 throws com.liferay.portal.kernel.exception.SystemException, 2360 com.liferay.portlet.asset.NoSuchCategoryException { 2361 return getPersistence().remove(categoryId); 2362 } 2363 2364 public static com.liferay.portlet.asset.model.AssetCategory updateImpl( 2365 com.liferay.portlet.asset.model.AssetCategory assetCategory) 2366 throws com.liferay.portal.kernel.exception.SystemException { 2367 return getPersistence().updateImpl(assetCategory); 2368 } 2369 2370 /** 2371 * Returns the asset category with the primary key or throws a {@link com.liferay.portlet.asset.NoSuchCategoryException} if it could not be found. 2372 * 2373 * @param categoryId the primary key of the asset category 2374 * @return the asset category 2375 * @throws com.liferay.portlet.asset.NoSuchCategoryException if a asset category with the primary key could not be found 2376 * @throws SystemException if a system exception occurred 2377 */ 2378 public static com.liferay.portlet.asset.model.AssetCategory findByPrimaryKey( 2379 long categoryId) 2380 throws com.liferay.portal.kernel.exception.SystemException, 2381 com.liferay.portlet.asset.NoSuchCategoryException { 2382 return getPersistence().findByPrimaryKey(categoryId); 2383 } 2384 2385 /** 2386 * Returns the asset category with the primary key or returns <code>null</code> if it could not be found. 2387 * 2388 * @param categoryId the primary key of the asset category 2389 * @return the asset category, or <code>null</code> if a asset category with the primary key could not be found 2390 * @throws SystemException if a system exception occurred 2391 */ 2392 public static com.liferay.portlet.asset.model.AssetCategory fetchByPrimaryKey( 2393 long categoryId) 2394 throws com.liferay.portal.kernel.exception.SystemException { 2395 return getPersistence().fetchByPrimaryKey(categoryId); 2396 } 2397 2398 /** 2399 * Returns all the asset categories. 2400 * 2401 * @return the asset categories 2402 * @throws SystemException if a system exception occurred 2403 */ 2404 public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findAll() 2405 throws com.liferay.portal.kernel.exception.SystemException { 2406 return getPersistence().findAll(); 2407 } 2408 2409 /** 2410 * Returns a range of all the asset categories. 2411 * 2412 * <p> 2413 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2414 * </p> 2415 * 2416 * @param start the lower bound of the range of asset categories 2417 * @param end the upper bound of the range of asset categories (not inclusive) 2418 * @return the range of asset categories 2419 * @throws SystemException if a system exception occurred 2420 */ 2421 public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findAll( 2422 int start, int end) 2423 throws com.liferay.portal.kernel.exception.SystemException { 2424 return getPersistence().findAll(start, end); 2425 } 2426 2427 /** 2428 * Returns an ordered range of all the asset categories. 2429 * 2430 * <p> 2431 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2432 * </p> 2433 * 2434 * @param start the lower bound of the range of asset categories 2435 * @param end the upper bound of the range of asset categories (not inclusive) 2436 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2437 * @return the ordered range of asset categories 2438 * @throws SystemException if a system exception occurred 2439 */ 2440 public static java.util.List<com.liferay.portlet.asset.model.AssetCategory> findAll( 2441 int start, int end, 2442 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2443 throws com.liferay.portal.kernel.exception.SystemException { 2444 return getPersistence().findAll(start, end, orderByComparator); 2445 } 2446 2447 /** 2448 * Removes all the asset categories from the database. 2449 * 2450 * @throws SystemException if a system exception occurred 2451 */ 2452 public static void removeAll() 2453 throws com.liferay.portal.kernel.exception.SystemException { 2454 getPersistence().removeAll(); 2455 } 2456 2457 /** 2458 * Returns the number of asset categories. 2459 * 2460 * @return the number of asset categories 2461 * @throws SystemException if a system exception occurred 2462 */ 2463 public static int countAll() 2464 throws com.liferay.portal.kernel.exception.SystemException { 2465 return getPersistence().countAll(); 2466 } 2467 2468 /** 2469 * Returns all the asset entries associated with the asset category. 2470 * 2471 * @param pk the primary key of the asset category 2472 * @return the asset entries associated with the asset category 2473 * @throws SystemException if a system exception occurred 2474 */ 2475 public static java.util.List<com.liferay.portlet.asset.model.AssetEntry> getAssetEntries( 2476 long pk) throws com.liferay.portal.kernel.exception.SystemException { 2477 return getPersistence().getAssetEntries(pk); 2478 } 2479 2480 /** 2481 * Returns a range of all the asset entries associated with the asset category. 2482 * 2483 * <p> 2484 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result 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. 2485 * </p> 2486 * 2487 * @param pk the primary key of the asset category 2488 * @param start the lower bound of the range of asset categories 2489 * @param end the upper bound of the range of asset categories (not inclusive) 2490 * @return the range of asset entries associated with the asset category 2491 * @throws SystemException if a system exception occurred 2492 */ 2493 public static java.util.List<com.liferay.portlet.asset.model.AssetEntry> getAssetEntries( 2494 long pk, int start, int end) 2495 throws com.liferay.portal.kernel.exception.SystemException { 2496 return getPersistence().getAssetEntries(pk, start, end); 2497 } 2498 2499 /** 2500 * Returns an ordered range of all the asset entries associated with the asset category. 2501 * 2502 * <p> 2503 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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. 2504 * </p> 2505 * 2506 * @param pk the primary key of the asset category 2507 * @param start the lower bound of the range of asset categories 2508 * @param end the upper bound of the range of asset categories (not inclusive) 2509 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2510 * @return the ordered range of asset entries associated with the asset category 2511 * @throws SystemException if a system exception occurred 2512 */ 2513 public static java.util.List<com.liferay.portlet.asset.model.AssetEntry> getAssetEntries( 2514 long pk, int start, int end, 2515 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 2516 throws com.liferay.portal.kernel.exception.SystemException { 2517 return getPersistence() 2518 .getAssetEntries(pk, start, end, orderByComparator); 2519 } 2520 2521 /** 2522 * Returns the number of asset entries associated with the asset category. 2523 * 2524 * @param pk the primary key of the asset category 2525 * @return the number of asset entries associated with the asset category 2526 * @throws SystemException if a system exception occurred 2527 */ 2528 public static int getAssetEntriesSize(long pk) 2529 throws com.liferay.portal.kernel.exception.SystemException { 2530 return getPersistence().getAssetEntriesSize(pk); 2531 } 2532 2533 /** 2534 * Returns <code>true</code> if the asset entry is associated with the asset category. 2535 * 2536 * @param pk the primary key of the asset category 2537 * @param assetEntryPK the primary key of the asset entry 2538 * @return <code>true</code> if the asset entry is associated with the asset category; <code>false</code> otherwise 2539 * @throws SystemException if a system exception occurred 2540 */ 2541 public static boolean containsAssetEntry(long pk, long assetEntryPK) 2542 throws com.liferay.portal.kernel.exception.SystemException { 2543 return getPersistence().containsAssetEntry(pk, assetEntryPK); 2544 } 2545 2546 /** 2547 * Returns <code>true</code> if the asset category has any asset entries associated with it. 2548 * 2549 * @param pk the primary key of the asset category to check for associations with asset entries 2550 * @return <code>true</code> if the asset category has any asset entries associated with it; <code>false</code> otherwise 2551 * @throws SystemException if a system exception occurred 2552 */ 2553 public static boolean containsAssetEntries(long pk) 2554 throws com.liferay.portal.kernel.exception.SystemException { 2555 return getPersistence().containsAssetEntries(pk); 2556 } 2557 2558 /** 2559 * Adds an association between the asset category and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2560 * 2561 * @param pk the primary key of the asset category 2562 * @param assetEntryPK the primary key of the asset entry 2563 * @throws SystemException if a system exception occurred 2564 */ 2565 public static void addAssetEntry(long pk, long assetEntryPK) 2566 throws com.liferay.portal.kernel.exception.SystemException { 2567 getPersistence().addAssetEntry(pk, assetEntryPK); 2568 } 2569 2570 /** 2571 * Adds an association between the asset category and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2572 * 2573 * @param pk the primary key of the asset category 2574 * @param assetEntry the asset entry 2575 * @throws SystemException if a system exception occurred 2576 */ 2577 public static void addAssetEntry(long pk, 2578 com.liferay.portlet.asset.model.AssetEntry assetEntry) 2579 throws com.liferay.portal.kernel.exception.SystemException { 2580 getPersistence().addAssetEntry(pk, assetEntry); 2581 } 2582 2583 /** 2584 * Adds an association between the asset category and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2585 * 2586 * @param pk the primary key of the asset category 2587 * @param assetEntryPKs the primary keys of the asset entries 2588 * @throws SystemException if a system exception occurred 2589 */ 2590 public static void addAssetEntries(long pk, long[] assetEntryPKs) 2591 throws com.liferay.portal.kernel.exception.SystemException { 2592 getPersistence().addAssetEntries(pk, assetEntryPKs); 2593 } 2594 2595 /** 2596 * Adds an association between the asset category and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2597 * 2598 * @param pk the primary key of the asset category 2599 * @param assetEntries the asset entries 2600 * @throws SystemException if a system exception occurred 2601 */ 2602 public static void addAssetEntries(long pk, 2603 java.util.List<com.liferay.portlet.asset.model.AssetEntry> assetEntries) 2604 throws com.liferay.portal.kernel.exception.SystemException { 2605 getPersistence().addAssetEntries(pk, assetEntries); 2606 } 2607 2608 /** 2609 * Clears all associations between the asset category and its asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2610 * 2611 * @param pk the primary key of the asset category to clear the associated asset entries from 2612 * @throws SystemException if a system exception occurred 2613 */ 2614 public static void clearAssetEntries(long pk) 2615 throws com.liferay.portal.kernel.exception.SystemException { 2616 getPersistence().clearAssetEntries(pk); 2617 } 2618 2619 /** 2620 * Removes the association between the asset category and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2621 * 2622 * @param pk the primary key of the asset category 2623 * @param assetEntryPK the primary key of the asset entry 2624 * @throws SystemException if a system exception occurred 2625 */ 2626 public static void removeAssetEntry(long pk, long assetEntryPK) 2627 throws com.liferay.portal.kernel.exception.SystemException { 2628 getPersistence().removeAssetEntry(pk, assetEntryPK); 2629 } 2630 2631 /** 2632 * Removes the association between the asset category and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2633 * 2634 * @param pk the primary key of the asset category 2635 * @param assetEntry the asset entry 2636 * @throws SystemException if a system exception occurred 2637 */ 2638 public static void removeAssetEntry(long pk, 2639 com.liferay.portlet.asset.model.AssetEntry assetEntry) 2640 throws com.liferay.portal.kernel.exception.SystemException { 2641 getPersistence().removeAssetEntry(pk, assetEntry); 2642 } 2643 2644 /** 2645 * Removes the association between the asset category and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2646 * 2647 * @param pk the primary key of the asset category 2648 * @param assetEntryPKs the primary keys of the asset entries 2649 * @throws SystemException if a system exception occurred 2650 */ 2651 public static void removeAssetEntries(long pk, long[] assetEntryPKs) 2652 throws com.liferay.portal.kernel.exception.SystemException { 2653 getPersistence().removeAssetEntries(pk, assetEntryPKs); 2654 } 2655 2656 /** 2657 * Removes the association between the asset category and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2658 * 2659 * @param pk the primary key of the asset category 2660 * @param assetEntries the asset entries 2661 * @throws SystemException if a system exception occurred 2662 */ 2663 public static void removeAssetEntries(long pk, 2664 java.util.List<com.liferay.portlet.asset.model.AssetEntry> assetEntries) 2665 throws com.liferay.portal.kernel.exception.SystemException { 2666 getPersistence().removeAssetEntries(pk, assetEntries); 2667 } 2668 2669 /** 2670 * 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. 2671 * 2672 * @param pk the primary key of the asset category 2673 * @param assetEntryPKs the primary keys of the asset entries to be associated with the asset category 2674 * @throws SystemException if a system exception occurred 2675 */ 2676 public static void setAssetEntries(long pk, long[] assetEntryPKs) 2677 throws com.liferay.portal.kernel.exception.SystemException { 2678 getPersistence().setAssetEntries(pk, assetEntryPKs); 2679 } 2680 2681 /** 2682 * 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. 2683 * 2684 * @param pk the primary key of the asset category 2685 * @param assetEntries the asset entries to be associated with the asset category 2686 * @throws SystemException if a system exception occurred 2687 */ 2688 public static void setAssetEntries(long pk, 2689 java.util.List<com.liferay.portlet.asset.model.AssetEntry> assetEntries) 2690 throws com.liferay.portal.kernel.exception.SystemException { 2691 getPersistence().setAssetEntries(pk, assetEntries); 2692 } 2693 2694 /** 2695 * Rebuilds the asset categories tree for the scope using the modified pre-order tree traversal algorithm. 2696 * 2697 * <p> 2698 * 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. 2699 * </p> 2700 * 2701 * @param groupId the ID of the scope 2702 * @param force whether to force the rebuild even if the tree is not stale 2703 */ 2704 public static void rebuildTree(long groupId, boolean force) 2705 throws com.liferay.portal.kernel.exception.SystemException { 2706 getPersistence().rebuildTree(groupId, force); 2707 } 2708 2709 public static void setRebuildTreeEnabled(boolean rebuildTreeEnabled) { 2710 getPersistence().setRebuildTreeEnabled(rebuildTreeEnabled); 2711 } 2712 2713 public static AssetCategoryPersistence getPersistence() { 2714 if (_persistence == null) { 2715 _persistence = (AssetCategoryPersistence)PortalBeanLocatorUtil.locate(AssetCategoryPersistence.class.getName()); 2716 2717 ReferenceRegistry.registerReference(AssetCategoryUtil.class, 2718 "_persistence"); 2719 } 2720 2721 return _persistence; 2722 } 2723 2724 /** 2725 * @deprecated 2726 */ 2727 public void setPersistence(AssetCategoryPersistence persistence) { 2728 } 2729 2730 private static AssetCategoryPersistence _persistence; 2731 }