001 /** 002 * Copyright (c) 2000-present Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portlet.asset.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.service.persistence.BasePersistence; 020 021 import com.liferay.portlet.asset.model.AssetCategory; 022 023 /** 024 * The persistence interface for the asset category service. 025 * 026 * <p> 027 * Caching information and settings can be found in <code>portal.properties</code> 028 * </p> 029 * 030 * @author Brian Wing Shun Chan 031 * @see com.liferay.portlet.asset.service.persistence.impl.AssetCategoryPersistenceImpl 032 * @see AssetCategoryUtil 033 * @generated 034 */ 035 @ProviderType 036 public interface AssetCategoryPersistence extends BasePersistence<AssetCategory> { 037 /* 038 * NOTE FOR DEVELOPERS: 039 * 040 * Never modify or reference this interface directly. Always use {@link AssetCategoryUtil} to access the asset category persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface. 041 */ 042 043 /** 044 * Returns all the asset categories where uuid = ?. 045 * 046 * @param uuid the uuid 047 * @return the matching asset categories 048 */ 049 public java.util.List<AssetCategory> findByUuid(java.lang.String uuid); 050 051 /** 052 * Returns a range of all the asset categories where uuid = ?. 053 * 054 * <p> 055 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 056 * </p> 057 * 058 * @param uuid the uuid 059 * @param start the lower bound of the range of asset categories 060 * @param end the upper bound of the range of asset categories (not inclusive) 061 * @return the range of matching asset categories 062 */ 063 public java.util.List<AssetCategory> findByUuid(java.lang.String uuid, 064 int start, int end); 065 066 /** 067 * Returns an ordered range of all the asset categories where uuid = ?. 068 * 069 * <p> 070 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 071 * </p> 072 * 073 * @param uuid the uuid 074 * @param start the lower bound of the range of asset categories 075 * @param end the upper bound of the range of asset categories (not inclusive) 076 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 077 * @return the ordered range of matching asset categories 078 */ 079 public java.util.List<AssetCategory> findByUuid(java.lang.String uuid, 080 int start, int end, 081 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 082 083 /** 084 * Returns the first asset category in the ordered set where uuid = ?. 085 * 086 * @param uuid the uuid 087 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 088 * @return the first matching asset category 089 * @throws NoSuchCategoryException if a matching asset category could not be found 090 */ 091 public AssetCategory findByUuid_First(java.lang.String uuid, 092 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 093 throws com.liferay.portlet.asset.NoSuchCategoryException; 094 095 /** 096 * Returns the first asset category in the ordered set where uuid = ?. 097 * 098 * @param uuid the uuid 099 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 100 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 101 */ 102 public AssetCategory fetchByUuid_First(java.lang.String uuid, 103 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 104 105 /** 106 * Returns the last asset category in the ordered set where uuid = ?. 107 * 108 * @param uuid the uuid 109 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 110 * @return the last matching asset category 111 * @throws NoSuchCategoryException if a matching asset category could not be found 112 */ 113 public AssetCategory findByUuid_Last(java.lang.String uuid, 114 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 115 throws com.liferay.portlet.asset.NoSuchCategoryException; 116 117 /** 118 * Returns the last asset category in the ordered set where uuid = ?. 119 * 120 * @param uuid the uuid 121 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 122 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 123 */ 124 public AssetCategory fetchByUuid_Last(java.lang.String uuid, 125 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 126 127 /** 128 * Returns the asset categories before and after the current asset category in the ordered set where uuid = ?. 129 * 130 * @param categoryId the primary key of the current asset category 131 * @param uuid the uuid 132 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 133 * @return the previous, current, and next asset category 134 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 135 */ 136 public AssetCategory[] findByUuid_PrevAndNext(long categoryId, 137 java.lang.String uuid, 138 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 139 throws com.liferay.portlet.asset.NoSuchCategoryException; 140 141 /** 142 * Removes all the asset categories where uuid = ? from the database. 143 * 144 * @param uuid the uuid 145 */ 146 public void removeByUuid(java.lang.String uuid); 147 148 /** 149 * Returns the number of asset categories where uuid = ?. 150 * 151 * @param uuid the uuid 152 * @return the number of matching asset categories 153 */ 154 public int countByUuid(java.lang.String uuid); 155 156 /** 157 * Returns the asset category where uuid = ? and groupId = ? or throws a {@link NoSuchCategoryException} if it could not be found. 158 * 159 * @param uuid the uuid 160 * @param groupId the group ID 161 * @return the matching asset category 162 * @throws NoSuchCategoryException if a matching asset category could not be found 163 */ 164 public AssetCategory findByUUID_G(java.lang.String uuid, long groupId) 165 throws com.liferay.portlet.asset.NoSuchCategoryException; 166 167 /** 168 * Returns the asset category where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 169 * 170 * @param uuid the uuid 171 * @param groupId the group ID 172 * @return the matching asset category, or <code>null</code> if a matching asset category could not be found 173 */ 174 public AssetCategory fetchByUUID_G(java.lang.String uuid, long groupId); 175 176 /** 177 * Returns the asset category where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 178 * 179 * @param uuid the uuid 180 * @param groupId the group ID 181 * @param retrieveFromCache whether to use the finder cache 182 * @return the matching asset category, or <code>null</code> if a matching asset category could not be found 183 */ 184 public AssetCategory fetchByUUID_G(java.lang.String uuid, long groupId, 185 boolean retrieveFromCache); 186 187 /** 188 * Removes the asset category where uuid = ? and groupId = ? from the database. 189 * 190 * @param uuid the uuid 191 * @param groupId the group ID 192 * @return the asset category that was removed 193 */ 194 public AssetCategory removeByUUID_G(java.lang.String uuid, long groupId) 195 throws com.liferay.portlet.asset.NoSuchCategoryException; 196 197 /** 198 * Returns the number of asset categories where uuid = ? and groupId = ?. 199 * 200 * @param uuid the uuid 201 * @param groupId the group ID 202 * @return the number of matching asset categories 203 */ 204 public int countByUUID_G(java.lang.String uuid, long groupId); 205 206 /** 207 * Returns all the asset categories where uuid = ? and companyId = ?. 208 * 209 * @param uuid the uuid 210 * @param companyId the company ID 211 * @return the matching asset categories 212 */ 213 public java.util.List<AssetCategory> findByUuid_C(java.lang.String uuid, 214 long companyId); 215 216 /** 217 * Returns a range of all the asset categories where uuid = ? and companyId = ?. 218 * 219 * <p> 220 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 221 * </p> 222 * 223 * @param uuid the uuid 224 * @param companyId the company ID 225 * @param start the lower bound of the range of asset categories 226 * @param end the upper bound of the range of asset categories (not inclusive) 227 * @return the range of matching asset categories 228 */ 229 public java.util.List<AssetCategory> findByUuid_C(java.lang.String uuid, 230 long companyId, int start, int end); 231 232 /** 233 * Returns an ordered range of all the asset categories where uuid = ? and companyId = ?. 234 * 235 * <p> 236 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 237 * </p> 238 * 239 * @param uuid the uuid 240 * @param companyId the company ID 241 * @param start the lower bound of the range of asset categories 242 * @param end the upper bound of the range of asset categories (not inclusive) 243 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 244 * @return the ordered range of matching asset categories 245 */ 246 public java.util.List<AssetCategory> findByUuid_C(java.lang.String uuid, 247 long companyId, int start, int end, 248 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 249 250 /** 251 * Returns the first asset category in the ordered set where uuid = ? and companyId = ?. 252 * 253 * @param uuid the uuid 254 * @param companyId the company ID 255 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 256 * @return the first matching asset category 257 * @throws NoSuchCategoryException if a matching asset category could not be found 258 */ 259 public AssetCategory findByUuid_C_First(java.lang.String uuid, 260 long companyId, 261 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 262 throws com.liferay.portlet.asset.NoSuchCategoryException; 263 264 /** 265 * Returns the first asset category in the ordered set where uuid = ? and companyId = ?. 266 * 267 * @param uuid the uuid 268 * @param companyId the company ID 269 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 270 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 271 */ 272 public AssetCategory fetchByUuid_C_First(java.lang.String uuid, 273 long companyId, 274 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 275 276 /** 277 * Returns the last asset category in the ordered set where uuid = ? and companyId = ?. 278 * 279 * @param uuid the uuid 280 * @param companyId the company ID 281 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 282 * @return the last matching asset category 283 * @throws NoSuchCategoryException if a matching asset category could not be found 284 */ 285 public AssetCategory findByUuid_C_Last(java.lang.String uuid, 286 long companyId, 287 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 288 throws com.liferay.portlet.asset.NoSuchCategoryException; 289 290 /** 291 * Returns the last asset category in the ordered set where uuid = ? and companyId = ?. 292 * 293 * @param uuid the uuid 294 * @param companyId the company ID 295 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 296 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 297 */ 298 public AssetCategory fetchByUuid_C_Last(java.lang.String uuid, 299 long companyId, 300 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 301 302 /** 303 * Returns the asset categories before and after the current asset category in the ordered set where uuid = ? and companyId = ?. 304 * 305 * @param categoryId the primary key of the current asset category 306 * @param uuid the uuid 307 * @param companyId the company ID 308 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 309 * @return the previous, current, and next asset category 310 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 311 */ 312 public AssetCategory[] findByUuid_C_PrevAndNext(long categoryId, 313 java.lang.String uuid, long companyId, 314 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 315 throws com.liferay.portlet.asset.NoSuchCategoryException; 316 317 /** 318 * Removes all the asset categories where uuid = ? and companyId = ? from the database. 319 * 320 * @param uuid the uuid 321 * @param companyId the company ID 322 */ 323 public void removeByUuid_C(java.lang.String uuid, long companyId); 324 325 /** 326 * Returns the number of asset categories where uuid = ? and companyId = ?. 327 * 328 * @param uuid the uuid 329 * @param companyId the company ID 330 * @return the number of matching asset categories 331 */ 332 public int countByUuid_C(java.lang.String uuid, long companyId); 333 334 /** 335 * Returns all the asset categories where groupId = ?. 336 * 337 * @param groupId the group ID 338 * @return the matching asset categories 339 */ 340 public java.util.List<AssetCategory> findByGroupId(long groupId); 341 342 /** 343 * Returns a range of all the asset categories where groupId = ?. 344 * 345 * <p> 346 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 347 * </p> 348 * 349 * @param groupId the group ID 350 * @param start the lower bound of the range of asset categories 351 * @param end the upper bound of the range of asset categories (not inclusive) 352 * @return the range of matching asset categories 353 */ 354 public java.util.List<AssetCategory> findByGroupId(long groupId, int start, 355 int end); 356 357 /** 358 * Returns an ordered range of all the asset categories where groupId = ?. 359 * 360 * <p> 361 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 362 * </p> 363 * 364 * @param groupId the group ID 365 * @param start the lower bound of the range of asset categories 366 * @param end the upper bound of the range of asset categories (not inclusive) 367 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 368 * @return the ordered range of matching asset categories 369 */ 370 public java.util.List<AssetCategory> findByGroupId(long groupId, int start, 371 int end, 372 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 373 374 /** 375 * Returns the first asset category in the ordered set where groupId = ?. 376 * 377 * @param groupId the group ID 378 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 379 * @return the first matching asset category 380 * @throws NoSuchCategoryException if a matching asset category could not be found 381 */ 382 public AssetCategory findByGroupId_First(long groupId, 383 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 384 throws com.liferay.portlet.asset.NoSuchCategoryException; 385 386 /** 387 * Returns the first asset category in the ordered set where groupId = ?. 388 * 389 * @param groupId the group ID 390 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 391 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 392 */ 393 public AssetCategory fetchByGroupId_First(long groupId, 394 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 395 396 /** 397 * Returns the last asset category in the ordered set where groupId = ?. 398 * 399 * @param groupId the group ID 400 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 401 * @return the last matching asset category 402 * @throws NoSuchCategoryException if a matching asset category could not be found 403 */ 404 public AssetCategory findByGroupId_Last(long groupId, 405 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 406 throws com.liferay.portlet.asset.NoSuchCategoryException; 407 408 /** 409 * Returns the last asset category in the ordered set where groupId = ?. 410 * 411 * @param groupId the group ID 412 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 413 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 414 */ 415 public AssetCategory fetchByGroupId_Last(long groupId, 416 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 417 418 /** 419 * Returns the asset categories before and after the current asset category in the ordered set where groupId = ?. 420 * 421 * @param categoryId the primary key of the current asset category 422 * @param groupId the group ID 423 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 424 * @return the previous, current, and next asset category 425 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 426 */ 427 public AssetCategory[] findByGroupId_PrevAndNext(long categoryId, 428 long groupId, 429 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 430 throws com.liferay.portlet.asset.NoSuchCategoryException; 431 432 /** 433 * Returns all the asset categories that the user has permission to view where groupId = ?. 434 * 435 * @param groupId the group ID 436 * @return the matching asset categories that the user has permission to view 437 */ 438 public java.util.List<AssetCategory> filterFindByGroupId(long groupId); 439 440 /** 441 * Returns a range of all the asset categories that the user has permission to view where groupId = ?. 442 * 443 * <p> 444 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 445 * </p> 446 * 447 * @param groupId the group ID 448 * @param start the lower bound of the range of asset categories 449 * @param end the upper bound of the range of asset categories (not inclusive) 450 * @return the range of matching asset categories that the user has permission to view 451 */ 452 public java.util.List<AssetCategory> filterFindByGroupId(long groupId, 453 int start, int end); 454 455 /** 456 * Returns an ordered range of all the asset categories that the user has permissions to view where groupId = ?. 457 * 458 * <p> 459 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 460 * </p> 461 * 462 * @param groupId the group ID 463 * @param start the lower bound of the range of asset categories 464 * @param end the upper bound of the range of asset categories (not inclusive) 465 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 466 * @return the ordered range of matching asset categories that the user has permission to view 467 */ 468 public java.util.List<AssetCategory> filterFindByGroupId(long groupId, 469 int start, int end, 470 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 471 472 /** 473 * 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 = ?. 474 * 475 * @param categoryId the primary key of the current asset category 476 * @param groupId the group ID 477 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 478 * @return the previous, current, and next asset category 479 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 480 */ 481 public AssetCategory[] filterFindByGroupId_PrevAndNext(long categoryId, 482 long groupId, 483 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 484 throws com.liferay.portlet.asset.NoSuchCategoryException; 485 486 /** 487 * Removes all the asset categories where groupId = ? from the database. 488 * 489 * @param groupId the group ID 490 */ 491 public void removeByGroupId(long groupId); 492 493 /** 494 * Returns the number of asset categories where groupId = ?. 495 * 496 * @param groupId the group ID 497 * @return the number of matching asset categories 498 */ 499 public int countByGroupId(long groupId); 500 501 /** 502 * Returns the number of asset categories that the user has permission to view where groupId = ?. 503 * 504 * @param groupId the group ID 505 * @return the number of matching asset categories that the user has permission to view 506 */ 507 public int filterCountByGroupId(long groupId); 508 509 /** 510 * Returns all the asset categories where parentCategoryId = ?. 511 * 512 * @param parentCategoryId the parent category ID 513 * @return the matching asset categories 514 */ 515 public java.util.List<AssetCategory> findByParentCategoryId( 516 long parentCategoryId); 517 518 /** 519 * Returns a range of all the asset categories where parentCategoryId = ?. 520 * 521 * <p> 522 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 523 * </p> 524 * 525 * @param parentCategoryId the parent category ID 526 * @param start the lower bound of the range of asset categories 527 * @param end the upper bound of the range of asset categories (not inclusive) 528 * @return the range of matching asset categories 529 */ 530 public java.util.List<AssetCategory> findByParentCategoryId( 531 long parentCategoryId, int start, int end); 532 533 /** 534 * Returns an ordered range of all the asset categories where parentCategoryId = ?. 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 QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 538 * </p> 539 * 540 * @param parentCategoryId the parent category 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 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 544 * @return the ordered range of matching asset categories 545 */ 546 public java.util.List<AssetCategory> findByParentCategoryId( 547 long parentCategoryId, int start, int end, 548 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 549 550 /** 551 * Returns the first asset category in the ordered set where parentCategoryId = ?. 552 * 553 * @param parentCategoryId the parent category ID 554 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 555 * @return the first matching asset category 556 * @throws NoSuchCategoryException if a matching asset category could not be found 557 */ 558 public AssetCategory findByParentCategoryId_First(long parentCategoryId, 559 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 560 throws com.liferay.portlet.asset.NoSuchCategoryException; 561 562 /** 563 * Returns the first asset category in the ordered set where parentCategoryId = ?. 564 * 565 * @param parentCategoryId the parent category ID 566 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 567 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 568 */ 569 public AssetCategory fetchByParentCategoryId_First(long parentCategoryId, 570 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 571 572 /** 573 * Returns the last asset category in the ordered set where parentCategoryId = ?. 574 * 575 * @param parentCategoryId the parent category ID 576 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 577 * @return the last matching asset category 578 * @throws NoSuchCategoryException if a matching asset category could not be found 579 */ 580 public AssetCategory findByParentCategoryId_Last(long parentCategoryId, 581 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 582 throws com.liferay.portlet.asset.NoSuchCategoryException; 583 584 /** 585 * Returns the last asset category in the ordered set where parentCategoryId = ?. 586 * 587 * @param parentCategoryId the parent category ID 588 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 589 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 590 */ 591 public AssetCategory fetchByParentCategoryId_Last(long parentCategoryId, 592 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 593 594 /** 595 * Returns the asset categories before and after the current asset category in the ordered set where parentCategoryId = ?. 596 * 597 * @param categoryId the primary key of the current asset category 598 * @param parentCategoryId the parent category ID 599 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 600 * @return the previous, current, and next asset category 601 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 602 */ 603 public AssetCategory[] findByParentCategoryId_PrevAndNext(long categoryId, 604 long parentCategoryId, 605 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 606 throws com.liferay.portlet.asset.NoSuchCategoryException; 607 608 /** 609 * Removes all the asset categories where parentCategoryId = ? from the database. 610 * 611 * @param parentCategoryId the parent category ID 612 */ 613 public void removeByParentCategoryId(long parentCategoryId); 614 615 /** 616 * Returns the number of asset categories where parentCategoryId = ?. 617 * 618 * @param parentCategoryId the parent category ID 619 * @return the number of matching asset categories 620 */ 621 public int countByParentCategoryId(long parentCategoryId); 622 623 /** 624 * Returns all the asset categories where vocabularyId = ?. 625 * 626 * @param vocabularyId the vocabulary ID 627 * @return the matching asset categories 628 */ 629 public java.util.List<AssetCategory> findByVocabularyId(long vocabularyId); 630 631 /** 632 * Returns a range of all the asset categories where vocabularyId = ?. 633 * 634 * <p> 635 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 636 * </p> 637 * 638 * @param vocabularyId the vocabulary ID 639 * @param start the lower bound of the range of asset categories 640 * @param end the upper bound of the range of asset categories (not inclusive) 641 * @return the range of matching asset categories 642 */ 643 public java.util.List<AssetCategory> findByVocabularyId(long vocabularyId, 644 int start, int end); 645 646 /** 647 * Returns an ordered range of all the asset categories where vocabularyId = ?. 648 * 649 * <p> 650 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 651 * </p> 652 * 653 * @param vocabularyId the vocabulary ID 654 * @param start the lower bound of the range of asset categories 655 * @param end the upper bound of the range of asset categories (not inclusive) 656 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 657 * @return the ordered range of matching asset categories 658 */ 659 public java.util.List<AssetCategory> findByVocabularyId(long vocabularyId, 660 int start, int end, 661 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 662 663 /** 664 * Returns the first asset category in the ordered set where vocabularyId = ?. 665 * 666 * @param vocabularyId the vocabulary ID 667 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 668 * @return the first matching asset category 669 * @throws NoSuchCategoryException if a matching asset category could not be found 670 */ 671 public AssetCategory findByVocabularyId_First(long vocabularyId, 672 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 673 throws com.liferay.portlet.asset.NoSuchCategoryException; 674 675 /** 676 * Returns the first asset category in the ordered set where vocabularyId = ?. 677 * 678 * @param vocabularyId the vocabulary ID 679 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 680 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 681 */ 682 public AssetCategory fetchByVocabularyId_First(long vocabularyId, 683 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 684 685 /** 686 * Returns the last asset category in the ordered set where vocabularyId = ?. 687 * 688 * @param vocabularyId the vocabulary ID 689 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 690 * @return the last matching asset category 691 * @throws NoSuchCategoryException if a matching asset category could not be found 692 */ 693 public AssetCategory findByVocabularyId_Last(long vocabularyId, 694 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 695 throws com.liferay.portlet.asset.NoSuchCategoryException; 696 697 /** 698 * Returns the last asset category in the ordered set where vocabularyId = ?. 699 * 700 * @param vocabularyId the vocabulary ID 701 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 702 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 703 */ 704 public AssetCategory fetchByVocabularyId_Last(long vocabularyId, 705 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 706 707 /** 708 * Returns the asset categories before and after the current asset category in the ordered set where vocabularyId = ?. 709 * 710 * @param categoryId the primary key of the current asset category 711 * @param vocabularyId the vocabulary ID 712 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 713 * @return the previous, current, and next asset category 714 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 715 */ 716 public AssetCategory[] findByVocabularyId_PrevAndNext(long categoryId, 717 long vocabularyId, 718 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 719 throws com.liferay.portlet.asset.NoSuchCategoryException; 720 721 /** 722 * Removes all the asset categories where vocabularyId = ? from the database. 723 * 724 * @param vocabularyId the vocabulary ID 725 */ 726 public void removeByVocabularyId(long vocabularyId); 727 728 /** 729 * Returns the number of asset categories where vocabularyId = ?. 730 * 731 * @param vocabularyId the vocabulary ID 732 * @return the number of matching asset categories 733 */ 734 public int countByVocabularyId(long vocabularyId); 735 736 /** 737 * Returns all the asset categories where groupId = ? and vocabularyId = ?. 738 * 739 * @param groupId the group ID 740 * @param vocabularyId the vocabulary ID 741 * @return the matching asset categories 742 */ 743 public java.util.List<AssetCategory> findByG_V(long groupId, 744 long vocabularyId); 745 746 /** 747 * Returns a range of all the asset categories where groupId = ? and vocabularyId = ?. 748 * 749 * <p> 750 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 751 * </p> 752 * 753 * @param groupId the group ID 754 * @param vocabularyId the vocabulary ID 755 * @param start the lower bound of the range of asset categories 756 * @param end the upper bound of the range of asset categories (not inclusive) 757 * @return the range of matching asset categories 758 */ 759 public java.util.List<AssetCategory> findByG_V(long groupId, 760 long vocabularyId, int start, int end); 761 762 /** 763 * Returns an ordered range of all the asset categories where groupId = ? and vocabularyId = ?. 764 * 765 * <p> 766 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 767 * </p> 768 * 769 * @param groupId the group ID 770 * @param vocabularyId the vocabulary ID 771 * @param start the lower bound of the range of asset categories 772 * @param end the upper bound of the range of asset categories (not inclusive) 773 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 774 * @return the ordered range of matching asset categories 775 */ 776 public java.util.List<AssetCategory> findByG_V(long groupId, 777 long vocabularyId, int start, int end, 778 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 779 780 /** 781 * Returns the first asset category in the ordered set where groupId = ? and vocabularyId = ?. 782 * 783 * @param groupId the group ID 784 * @param vocabularyId the vocabulary ID 785 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 786 * @return the first matching asset category 787 * @throws NoSuchCategoryException if a matching asset category could not be found 788 */ 789 public AssetCategory findByG_V_First(long groupId, long vocabularyId, 790 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 791 throws com.liferay.portlet.asset.NoSuchCategoryException; 792 793 /** 794 * Returns the first asset category in the ordered set where groupId = ? and vocabularyId = ?. 795 * 796 * @param groupId the group ID 797 * @param vocabularyId the vocabulary ID 798 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 799 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 800 */ 801 public AssetCategory fetchByG_V_First(long groupId, long vocabularyId, 802 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 803 804 /** 805 * Returns the last asset category in the ordered set where groupId = ? and vocabularyId = ?. 806 * 807 * @param groupId the group ID 808 * @param vocabularyId the vocabulary ID 809 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 810 * @return the last matching asset category 811 * @throws NoSuchCategoryException if a matching asset category could not be found 812 */ 813 public AssetCategory findByG_V_Last(long groupId, long vocabularyId, 814 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 815 throws com.liferay.portlet.asset.NoSuchCategoryException; 816 817 /** 818 * Returns the last asset category in the ordered set where groupId = ? and vocabularyId = ?. 819 * 820 * @param groupId the group ID 821 * @param vocabularyId the vocabulary ID 822 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 823 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 824 */ 825 public AssetCategory fetchByG_V_Last(long groupId, long vocabularyId, 826 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 827 828 /** 829 * Returns the asset categories before and after the current asset category in the ordered set where groupId = ? and vocabularyId = ?. 830 * 831 * @param categoryId the primary key of the current asset category 832 * @param groupId the group ID 833 * @param vocabularyId the vocabulary ID 834 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 835 * @return the previous, current, and next asset category 836 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 837 */ 838 public AssetCategory[] findByG_V_PrevAndNext(long categoryId, long groupId, 839 long vocabularyId, 840 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 841 throws com.liferay.portlet.asset.NoSuchCategoryException; 842 843 /** 844 * Returns all the asset categories that the user has permission to view where groupId = ? and vocabularyId = ?. 845 * 846 * @param groupId the group ID 847 * @param vocabularyId the vocabulary ID 848 * @return the matching asset categories that the user has permission to view 849 */ 850 public java.util.List<AssetCategory> filterFindByG_V(long groupId, 851 long vocabularyId); 852 853 /** 854 * Returns a range of all the asset categories that the user has permission to view where groupId = ? and vocabularyId = ?. 855 * 856 * <p> 857 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 858 * </p> 859 * 860 * @param groupId the group ID 861 * @param vocabularyId the vocabulary ID 862 * @param start the lower bound of the range of asset categories 863 * @param end the upper bound of the range of asset categories (not inclusive) 864 * @return the range of matching asset categories that the user has permission to view 865 */ 866 public java.util.List<AssetCategory> filterFindByG_V(long groupId, 867 long vocabularyId, int start, int end); 868 869 /** 870 * Returns an ordered range of all the asset categories that the user has permissions to view where groupId = ? and vocabularyId = ?. 871 * 872 * <p> 873 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 874 * </p> 875 * 876 * @param groupId the group ID 877 * @param vocabularyId the vocabulary ID 878 * @param start the lower bound of the range of asset categories 879 * @param end the upper bound of the range of asset categories (not inclusive) 880 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 881 * @return the ordered range of matching asset categories that the user has permission to view 882 */ 883 public java.util.List<AssetCategory> filterFindByG_V(long groupId, 884 long vocabularyId, int start, int end, 885 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 886 887 /** 888 * 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 = ?. 889 * 890 * @param categoryId the primary key of the current asset category 891 * @param groupId the group ID 892 * @param vocabularyId the vocabulary ID 893 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 894 * @return the previous, current, and next asset category 895 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 896 */ 897 public AssetCategory[] filterFindByG_V_PrevAndNext(long categoryId, 898 long groupId, long vocabularyId, 899 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 900 throws com.liferay.portlet.asset.NoSuchCategoryException; 901 902 /** 903 * Returns all the asset categories that the user has permission to view where groupId = ? and vocabularyId = any ?. 904 * 905 * @param groupId the group ID 906 * @param vocabularyIds the vocabulary IDs 907 * @return the matching asset categories that the user has permission to view 908 */ 909 public java.util.List<AssetCategory> filterFindByG_V(long groupId, 910 long[] vocabularyIds); 911 912 /** 913 * Returns a range of all the asset categories that the user has permission to view where groupId = ? and vocabularyId = any ?. 914 * 915 * <p> 916 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 917 * </p> 918 * 919 * @param groupId the group ID 920 * @param vocabularyIds the vocabulary IDs 921 * @param start the lower bound of the range of asset categories 922 * @param end the upper bound of the range of asset categories (not inclusive) 923 * @return the range of matching asset categories that the user has permission to view 924 */ 925 public java.util.List<AssetCategory> filterFindByG_V(long groupId, 926 long[] vocabularyIds, int start, int end); 927 928 /** 929 * Returns an ordered range of all the asset categories that the user has permission to view where groupId = ? and vocabularyId = any ?. 930 * 931 * <p> 932 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 933 * </p> 934 * 935 * @param groupId the group ID 936 * @param vocabularyIds the vocabulary IDs 937 * @param start the lower bound of the range of asset categories 938 * @param end the upper bound of the range of asset categories (not inclusive) 939 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 940 * @return the ordered range of matching asset categories that the user has permission to view 941 */ 942 public java.util.List<AssetCategory> filterFindByG_V(long groupId, 943 long[] vocabularyIds, int start, int end, 944 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 945 946 /** 947 * Returns all the asset categories where groupId = ? and vocabularyId = any ?. 948 * 949 * <p> 950 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 951 * </p> 952 * 953 * @param groupId the group ID 954 * @param vocabularyIds the vocabulary IDs 955 * @return the matching asset categories 956 */ 957 public java.util.List<AssetCategory> findByG_V(long groupId, 958 long[] vocabularyIds); 959 960 /** 961 * Returns a range of all the asset categories where groupId = ? and vocabularyId = any ?. 962 * 963 * <p> 964 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 965 * </p> 966 * 967 * @param groupId the group ID 968 * @param vocabularyIds the vocabulary IDs 969 * @param start the lower bound of the range of asset categories 970 * @param end the upper bound of the range of asset categories (not inclusive) 971 * @return the range of matching asset categories 972 */ 973 public java.util.List<AssetCategory> findByG_V(long groupId, 974 long[] vocabularyIds, int start, int end); 975 976 /** 977 * Returns an ordered range of all the asset categories where groupId = ? and vocabularyId = any ?. 978 * 979 * <p> 980 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 981 * </p> 982 * 983 * @param groupId the group ID 984 * @param vocabularyIds the vocabulary IDs 985 * @param start the lower bound of the range of asset categories 986 * @param end the upper bound of the range of asset categories (not inclusive) 987 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 988 * @return the ordered range of matching asset categories 989 */ 990 public java.util.List<AssetCategory> findByG_V(long groupId, 991 long[] vocabularyIds, int start, int end, 992 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 993 994 /** 995 * Removes all the asset categories where groupId = ? and vocabularyId = ? from the database. 996 * 997 * @param groupId the group ID 998 * @param vocabularyId the vocabulary ID 999 */ 1000 public void removeByG_V(long groupId, long vocabularyId); 1001 1002 /** 1003 * Returns the number of asset categories where groupId = ? and vocabularyId = ?. 1004 * 1005 * @param groupId the group ID 1006 * @param vocabularyId the vocabulary ID 1007 * @return the number of matching asset categories 1008 */ 1009 public int countByG_V(long groupId, long vocabularyId); 1010 1011 /** 1012 * Returns the number of asset categories where groupId = ? and vocabularyId = any ?. 1013 * 1014 * @param groupId the group ID 1015 * @param vocabularyIds the vocabulary IDs 1016 * @return the number of matching asset categories 1017 */ 1018 public int countByG_V(long groupId, long[] vocabularyIds); 1019 1020 /** 1021 * Returns the number of asset categories that the user has permission to view where groupId = ? and vocabularyId = ?. 1022 * 1023 * @param groupId the group ID 1024 * @param vocabularyId the vocabulary ID 1025 * @return the number of matching asset categories that the user has permission to view 1026 */ 1027 public int filterCountByG_V(long groupId, long vocabularyId); 1028 1029 /** 1030 * Returns the number of asset categories that the user has permission to view where groupId = ? and vocabularyId = any ?. 1031 * 1032 * @param groupId the group ID 1033 * @param vocabularyIds the vocabulary IDs 1034 * @return the number of matching asset categories that the user has permission to view 1035 */ 1036 public int filterCountByG_V(long groupId, long[] vocabularyIds); 1037 1038 /** 1039 * Returns all the asset categories where parentCategoryId = ? and name = ?. 1040 * 1041 * @param parentCategoryId the parent category ID 1042 * @param name the name 1043 * @return the matching asset categories 1044 */ 1045 public java.util.List<AssetCategory> findByP_N(long parentCategoryId, 1046 java.lang.String name); 1047 1048 /** 1049 * Returns a range of all the asset categories where parentCategoryId = ? and name = ?. 1050 * 1051 * <p> 1052 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1053 * </p> 1054 * 1055 * @param parentCategoryId the parent category ID 1056 * @param name the name 1057 * @param start the lower bound of the range of asset categories 1058 * @param end the upper bound of the range of asset categories (not inclusive) 1059 * @return the range of matching asset categories 1060 */ 1061 public java.util.List<AssetCategory> findByP_N(long parentCategoryId, 1062 java.lang.String name, int start, int end); 1063 1064 /** 1065 * Returns an ordered range of all the asset categories where parentCategoryId = ? and name = ?. 1066 * 1067 * <p> 1068 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1069 * </p> 1070 * 1071 * @param parentCategoryId the parent category ID 1072 * @param name the name 1073 * @param start the lower bound of the range of asset categories 1074 * @param end the upper bound of the range of asset categories (not inclusive) 1075 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1076 * @return the ordered range of matching asset categories 1077 */ 1078 public java.util.List<AssetCategory> findByP_N(long parentCategoryId, 1079 java.lang.String name, int start, int end, 1080 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1081 1082 /** 1083 * Returns the first asset category in the ordered set where parentCategoryId = ? and name = ?. 1084 * 1085 * @param parentCategoryId the parent category ID 1086 * @param name the name 1087 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1088 * @return the first matching asset category 1089 * @throws NoSuchCategoryException if a matching asset category could not be found 1090 */ 1091 public AssetCategory findByP_N_First(long parentCategoryId, 1092 java.lang.String name, 1093 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 1094 throws com.liferay.portlet.asset.NoSuchCategoryException; 1095 1096 /** 1097 * Returns the first asset category in the ordered set where parentCategoryId = ? and name = ?. 1098 * 1099 * @param parentCategoryId the parent category ID 1100 * @param name the name 1101 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1102 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 1103 */ 1104 public AssetCategory fetchByP_N_First(long parentCategoryId, 1105 java.lang.String name, 1106 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1107 1108 /** 1109 * Returns the last asset category in the ordered set where parentCategoryId = ? and name = ?. 1110 * 1111 * @param parentCategoryId the parent category ID 1112 * @param name the name 1113 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1114 * @return the last matching asset category 1115 * @throws NoSuchCategoryException if a matching asset category could not be found 1116 */ 1117 public AssetCategory findByP_N_Last(long parentCategoryId, 1118 java.lang.String name, 1119 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 1120 throws com.liferay.portlet.asset.NoSuchCategoryException; 1121 1122 /** 1123 * Returns the last asset category in the ordered set where parentCategoryId = ? and name = ?. 1124 * 1125 * @param parentCategoryId the parent category ID 1126 * @param name the name 1127 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1128 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 1129 */ 1130 public AssetCategory fetchByP_N_Last(long parentCategoryId, 1131 java.lang.String name, 1132 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1133 1134 /** 1135 * Returns the asset categories before and after the current asset category in the ordered set where parentCategoryId = ? and name = ?. 1136 * 1137 * @param categoryId the primary key of the current asset category 1138 * @param parentCategoryId the parent category ID 1139 * @param name the name 1140 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1141 * @return the previous, current, and next asset category 1142 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 1143 */ 1144 public AssetCategory[] findByP_N_PrevAndNext(long categoryId, 1145 long parentCategoryId, java.lang.String name, 1146 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 1147 throws com.liferay.portlet.asset.NoSuchCategoryException; 1148 1149 /** 1150 * Removes all the asset categories where parentCategoryId = ? and name = ? from the database. 1151 * 1152 * @param parentCategoryId the parent category ID 1153 * @param name the name 1154 */ 1155 public void removeByP_N(long parentCategoryId, java.lang.String name); 1156 1157 /** 1158 * Returns the number of asset categories where parentCategoryId = ? and name = ?. 1159 * 1160 * @param parentCategoryId the parent category ID 1161 * @param name the name 1162 * @return the number of matching asset categories 1163 */ 1164 public int countByP_N(long parentCategoryId, java.lang.String name); 1165 1166 /** 1167 * Returns all the asset categories where parentCategoryId = ? and vocabularyId = ?. 1168 * 1169 * @param parentCategoryId the parent category ID 1170 * @param vocabularyId the vocabulary ID 1171 * @return the matching asset categories 1172 */ 1173 public java.util.List<AssetCategory> findByP_V(long parentCategoryId, 1174 long vocabularyId); 1175 1176 /** 1177 * Returns a range of all the asset categories where parentCategoryId = ? and vocabularyId = ?. 1178 * 1179 * <p> 1180 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1181 * </p> 1182 * 1183 * @param parentCategoryId the parent category ID 1184 * @param vocabularyId the vocabulary ID 1185 * @param start the lower bound of the range of asset categories 1186 * @param end the upper bound of the range of asset categories (not inclusive) 1187 * @return the range of matching asset categories 1188 */ 1189 public java.util.List<AssetCategory> findByP_V(long parentCategoryId, 1190 long vocabularyId, int start, int end); 1191 1192 /** 1193 * Returns an ordered range of all the asset categories where parentCategoryId = ? and vocabularyId = ?. 1194 * 1195 * <p> 1196 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1197 * </p> 1198 * 1199 * @param parentCategoryId the parent category ID 1200 * @param vocabularyId the vocabulary ID 1201 * @param start the lower bound of the range of asset categories 1202 * @param end the upper bound of the range of asset categories (not inclusive) 1203 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1204 * @return the ordered range of matching asset categories 1205 */ 1206 public java.util.List<AssetCategory> findByP_V(long parentCategoryId, 1207 long vocabularyId, int start, int end, 1208 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1209 1210 /** 1211 * Returns the first asset category in the ordered set where parentCategoryId = ? and vocabularyId = ?. 1212 * 1213 * @param parentCategoryId the parent category ID 1214 * @param vocabularyId the vocabulary ID 1215 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1216 * @return the first matching asset category 1217 * @throws NoSuchCategoryException if a matching asset category could not be found 1218 */ 1219 public AssetCategory findByP_V_First(long parentCategoryId, 1220 long vocabularyId, 1221 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 1222 throws com.liferay.portlet.asset.NoSuchCategoryException; 1223 1224 /** 1225 * Returns the first asset category in the ordered set where parentCategoryId = ? and vocabularyId = ?. 1226 * 1227 * @param parentCategoryId the parent category ID 1228 * @param vocabularyId the vocabulary ID 1229 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1230 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 1231 */ 1232 public AssetCategory fetchByP_V_First(long parentCategoryId, 1233 long vocabularyId, 1234 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1235 1236 /** 1237 * Returns the last asset category in the ordered set where parentCategoryId = ? and vocabularyId = ?. 1238 * 1239 * @param parentCategoryId the parent category ID 1240 * @param vocabularyId the vocabulary ID 1241 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1242 * @return the last matching asset category 1243 * @throws NoSuchCategoryException if a matching asset category could not be found 1244 */ 1245 public AssetCategory findByP_V_Last(long parentCategoryId, 1246 long vocabularyId, 1247 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 1248 throws com.liferay.portlet.asset.NoSuchCategoryException; 1249 1250 /** 1251 * Returns the last asset category in the ordered set where parentCategoryId = ? and vocabularyId = ?. 1252 * 1253 * @param parentCategoryId the parent category ID 1254 * @param vocabularyId the vocabulary ID 1255 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1256 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 1257 */ 1258 public AssetCategory fetchByP_V_Last(long parentCategoryId, 1259 long vocabularyId, 1260 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1261 1262 /** 1263 * Returns the asset categories before and after the current asset category in the ordered set where parentCategoryId = ? and vocabularyId = ?. 1264 * 1265 * @param categoryId the primary key of the current asset category 1266 * @param parentCategoryId the parent category ID 1267 * @param vocabularyId the vocabulary ID 1268 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1269 * @return the previous, current, and next asset category 1270 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 1271 */ 1272 public AssetCategory[] findByP_V_PrevAndNext(long categoryId, 1273 long parentCategoryId, long vocabularyId, 1274 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 1275 throws com.liferay.portlet.asset.NoSuchCategoryException; 1276 1277 /** 1278 * Removes all the asset categories where parentCategoryId = ? and vocabularyId = ? from the database. 1279 * 1280 * @param parentCategoryId the parent category ID 1281 * @param vocabularyId the vocabulary ID 1282 */ 1283 public void removeByP_V(long parentCategoryId, long vocabularyId); 1284 1285 /** 1286 * Returns the number of asset categories where parentCategoryId = ? and vocabularyId = ?. 1287 * 1288 * @param parentCategoryId the parent category ID 1289 * @param vocabularyId the vocabulary ID 1290 * @return the number of matching asset categories 1291 */ 1292 public int countByP_V(long parentCategoryId, long vocabularyId); 1293 1294 /** 1295 * Returns all the asset categories where name = ? and vocabularyId = ?. 1296 * 1297 * @param name the name 1298 * @param vocabularyId the vocabulary ID 1299 * @return the matching asset categories 1300 */ 1301 public java.util.List<AssetCategory> findByN_V(java.lang.String name, 1302 long vocabularyId); 1303 1304 /** 1305 * Returns a range of all the asset categories where name = ? and vocabularyId = ?. 1306 * 1307 * <p> 1308 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1309 * </p> 1310 * 1311 * @param name the name 1312 * @param vocabularyId the vocabulary ID 1313 * @param start the lower bound of the range of asset categories 1314 * @param end the upper bound of the range of asset categories (not inclusive) 1315 * @return the range of matching asset categories 1316 */ 1317 public java.util.List<AssetCategory> findByN_V(java.lang.String name, 1318 long vocabularyId, int start, int end); 1319 1320 /** 1321 * Returns an ordered range of all the asset categories where name = ? and vocabularyId = ?. 1322 * 1323 * <p> 1324 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1325 * </p> 1326 * 1327 * @param name the name 1328 * @param vocabularyId the vocabulary ID 1329 * @param start the lower bound of the range of asset categories 1330 * @param end the upper bound of the range of asset categories (not inclusive) 1331 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1332 * @return the ordered range of matching asset categories 1333 */ 1334 public java.util.List<AssetCategory> findByN_V(java.lang.String name, 1335 long vocabularyId, int start, int end, 1336 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1337 1338 /** 1339 * Returns the first asset category in the ordered set where name = ? and vocabularyId = ?. 1340 * 1341 * @param name the name 1342 * @param vocabularyId the vocabulary ID 1343 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1344 * @return the first matching asset category 1345 * @throws NoSuchCategoryException if a matching asset category could not be found 1346 */ 1347 public AssetCategory findByN_V_First(java.lang.String name, 1348 long vocabularyId, 1349 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 1350 throws com.liferay.portlet.asset.NoSuchCategoryException; 1351 1352 /** 1353 * Returns the first asset category in the ordered set where name = ? and vocabularyId = ?. 1354 * 1355 * @param name the name 1356 * @param vocabularyId the vocabulary ID 1357 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1358 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 1359 */ 1360 public AssetCategory fetchByN_V_First(java.lang.String name, 1361 long vocabularyId, 1362 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1363 1364 /** 1365 * Returns the last asset category in the ordered set where name = ? and vocabularyId = ?. 1366 * 1367 * @param name the name 1368 * @param vocabularyId the vocabulary ID 1369 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1370 * @return the last matching asset category 1371 * @throws NoSuchCategoryException if a matching asset category could not be found 1372 */ 1373 public AssetCategory findByN_V_Last(java.lang.String name, 1374 long vocabularyId, 1375 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 1376 throws com.liferay.portlet.asset.NoSuchCategoryException; 1377 1378 /** 1379 * Returns the last asset category in the ordered set where name = ? and vocabularyId = ?. 1380 * 1381 * @param name the name 1382 * @param vocabularyId the vocabulary ID 1383 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1384 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 1385 */ 1386 public AssetCategory fetchByN_V_Last(java.lang.String name, 1387 long vocabularyId, 1388 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1389 1390 /** 1391 * Returns the asset categories before and after the current asset category in the ordered set where name = ? and vocabularyId = ?. 1392 * 1393 * @param categoryId the primary key of the current asset category 1394 * @param name the name 1395 * @param vocabularyId the vocabulary ID 1396 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1397 * @return the previous, current, and next asset category 1398 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 1399 */ 1400 public AssetCategory[] findByN_V_PrevAndNext(long categoryId, 1401 java.lang.String name, long vocabularyId, 1402 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 1403 throws com.liferay.portlet.asset.NoSuchCategoryException; 1404 1405 /** 1406 * Removes all the asset categories where name = ? and vocabularyId = ? from the database. 1407 * 1408 * @param name the name 1409 * @param vocabularyId the vocabulary ID 1410 */ 1411 public void removeByN_V(java.lang.String name, long vocabularyId); 1412 1413 /** 1414 * Returns the number of asset categories where name = ? and vocabularyId = ?. 1415 * 1416 * @param name the name 1417 * @param vocabularyId the vocabulary ID 1418 * @return the number of matching asset categories 1419 */ 1420 public int countByN_V(java.lang.String name, long vocabularyId); 1421 1422 /** 1423 * Returns all the asset categories where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 1424 * 1425 * @param groupId the group ID 1426 * @param parentCategoryId the parent category ID 1427 * @param vocabularyId the vocabulary ID 1428 * @return the matching asset categories 1429 */ 1430 public java.util.List<AssetCategory> findByG_P_V(long groupId, 1431 long parentCategoryId, long vocabularyId); 1432 1433 /** 1434 * Returns a range of all the asset categories where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 1435 * 1436 * <p> 1437 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1438 * </p> 1439 * 1440 * @param groupId the group ID 1441 * @param parentCategoryId the parent category ID 1442 * @param vocabularyId the vocabulary ID 1443 * @param start the lower bound of the range of asset categories 1444 * @param end the upper bound of the range of asset categories (not inclusive) 1445 * @return the range of matching asset categories 1446 */ 1447 public java.util.List<AssetCategory> findByG_P_V(long groupId, 1448 long parentCategoryId, long vocabularyId, int start, int end); 1449 1450 /** 1451 * Returns an ordered range of all the asset categories where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 1452 * 1453 * <p> 1454 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1455 * </p> 1456 * 1457 * @param groupId the group ID 1458 * @param parentCategoryId the parent category ID 1459 * @param vocabularyId the vocabulary ID 1460 * @param start the lower bound of the range of asset categories 1461 * @param end the upper bound of the range of asset categories (not inclusive) 1462 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1463 * @return the ordered range of matching asset categories 1464 */ 1465 public java.util.List<AssetCategory> findByG_P_V(long groupId, 1466 long parentCategoryId, long vocabularyId, int start, int end, 1467 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1468 1469 /** 1470 * Returns the first asset category in the ordered set where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 1471 * 1472 * @param groupId the group ID 1473 * @param parentCategoryId the parent category ID 1474 * @param vocabularyId the vocabulary ID 1475 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1476 * @return the first matching asset category 1477 * @throws NoSuchCategoryException if a matching asset category could not be found 1478 */ 1479 public AssetCategory findByG_P_V_First(long groupId, long parentCategoryId, 1480 long vocabularyId, 1481 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 1482 throws com.liferay.portlet.asset.NoSuchCategoryException; 1483 1484 /** 1485 * Returns the first asset category in the ordered set where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 1486 * 1487 * @param groupId the group ID 1488 * @param parentCategoryId the parent category ID 1489 * @param vocabularyId the vocabulary ID 1490 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1491 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 1492 */ 1493 public AssetCategory fetchByG_P_V_First(long groupId, 1494 long parentCategoryId, long vocabularyId, 1495 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1496 1497 /** 1498 * Returns the last asset category in the ordered set where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 1499 * 1500 * @param groupId the group ID 1501 * @param parentCategoryId the parent category ID 1502 * @param vocabularyId the vocabulary ID 1503 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1504 * @return the last matching asset category 1505 * @throws NoSuchCategoryException if a matching asset category could not be found 1506 */ 1507 public AssetCategory findByG_P_V_Last(long groupId, long parentCategoryId, 1508 long vocabularyId, 1509 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 1510 throws com.liferay.portlet.asset.NoSuchCategoryException; 1511 1512 /** 1513 * Returns the last asset category in the ordered set where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 1514 * 1515 * @param groupId the group ID 1516 * @param parentCategoryId the parent category ID 1517 * @param vocabularyId the vocabulary ID 1518 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1519 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 1520 */ 1521 public AssetCategory fetchByG_P_V_Last(long groupId, long parentCategoryId, 1522 long vocabularyId, 1523 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1524 1525 /** 1526 * Returns the asset categories before and after the current asset category in the ordered set where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 1527 * 1528 * @param categoryId the primary key of the current asset category 1529 * @param groupId the group ID 1530 * @param parentCategoryId the parent category ID 1531 * @param vocabularyId the vocabulary ID 1532 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1533 * @return the previous, current, and next asset category 1534 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 1535 */ 1536 public AssetCategory[] findByG_P_V_PrevAndNext(long categoryId, 1537 long groupId, long parentCategoryId, long vocabularyId, 1538 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 1539 throws com.liferay.portlet.asset.NoSuchCategoryException; 1540 1541 /** 1542 * Returns all the asset categories that the user has permission to view where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 1543 * 1544 * @param groupId the group ID 1545 * @param parentCategoryId the parent category ID 1546 * @param vocabularyId the vocabulary ID 1547 * @return the matching asset categories that the user has permission to view 1548 */ 1549 public java.util.List<AssetCategory> filterFindByG_P_V(long groupId, 1550 long parentCategoryId, long vocabularyId); 1551 1552 /** 1553 * Returns a range of all the asset categories that the user has permission to view where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 1554 * 1555 * <p> 1556 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1557 * </p> 1558 * 1559 * @param groupId the group ID 1560 * @param parentCategoryId the parent category ID 1561 * @param vocabularyId the vocabulary ID 1562 * @param start the lower bound of the range of asset categories 1563 * @param end the upper bound of the range of asset categories (not inclusive) 1564 * @return the range of matching asset categories that the user has permission to view 1565 */ 1566 public java.util.List<AssetCategory> filterFindByG_P_V(long groupId, 1567 long parentCategoryId, long vocabularyId, int start, int end); 1568 1569 /** 1570 * Returns an ordered range of all the asset categories that the user has permissions to view where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 1571 * 1572 * <p> 1573 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1574 * </p> 1575 * 1576 * @param groupId the group ID 1577 * @param parentCategoryId the parent category ID 1578 * @param vocabularyId the vocabulary ID 1579 * @param start the lower bound of the range of asset categories 1580 * @param end the upper bound of the range of asset categories (not inclusive) 1581 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1582 * @return the ordered range of matching asset categories that the user has permission to view 1583 */ 1584 public java.util.List<AssetCategory> filterFindByG_P_V(long groupId, 1585 long parentCategoryId, long vocabularyId, int start, int end, 1586 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1587 1588 /** 1589 * Returns the asset categories before and after the current asset category in the ordered set of asset categories that the user has permission to view where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 1590 * 1591 * @param categoryId the primary key of the current asset category 1592 * @param groupId the group ID 1593 * @param parentCategoryId the parent category ID 1594 * @param vocabularyId the vocabulary ID 1595 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1596 * @return the previous, current, and next asset category 1597 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 1598 */ 1599 public AssetCategory[] filterFindByG_P_V_PrevAndNext(long categoryId, 1600 long groupId, long parentCategoryId, long vocabularyId, 1601 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 1602 throws com.liferay.portlet.asset.NoSuchCategoryException; 1603 1604 /** 1605 * Removes all the asset categories where groupId = ? and parentCategoryId = ? and vocabularyId = ? from the database. 1606 * 1607 * @param groupId the group ID 1608 * @param parentCategoryId the parent category ID 1609 * @param vocabularyId the vocabulary ID 1610 */ 1611 public void removeByG_P_V(long groupId, long parentCategoryId, 1612 long vocabularyId); 1613 1614 /** 1615 * Returns the number of asset categories where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 1616 * 1617 * @param groupId the group ID 1618 * @param parentCategoryId the parent category ID 1619 * @param vocabularyId the vocabulary ID 1620 * @return the number of matching asset categories 1621 */ 1622 public int countByG_P_V(long groupId, long parentCategoryId, 1623 long vocabularyId); 1624 1625 /** 1626 * Returns the number of asset categories that the user has permission to view where groupId = ? and parentCategoryId = ? and vocabularyId = ?. 1627 * 1628 * @param groupId the group ID 1629 * @param parentCategoryId the parent category ID 1630 * @param vocabularyId the vocabulary ID 1631 * @return the number of matching asset categories that the user has permission to view 1632 */ 1633 public int filterCountByG_P_V(long groupId, long parentCategoryId, 1634 long vocabularyId); 1635 1636 /** 1637 * Returns all the asset categories where groupId = ? and name LIKE ? and vocabularyId = ?. 1638 * 1639 * @param groupId the group ID 1640 * @param name the name 1641 * @param vocabularyId the vocabulary ID 1642 * @return the matching asset categories 1643 */ 1644 public java.util.List<AssetCategory> findByG_LikeN_V(long groupId, 1645 java.lang.String name, long vocabularyId); 1646 1647 /** 1648 * Returns a range of all the asset categories where groupId = ? and name LIKE ? and vocabularyId = ?. 1649 * 1650 * <p> 1651 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1652 * </p> 1653 * 1654 * @param groupId the group ID 1655 * @param name the name 1656 * @param vocabularyId the vocabulary ID 1657 * @param start the lower bound of the range of asset categories 1658 * @param end the upper bound of the range of asset categories (not inclusive) 1659 * @return the range of matching asset categories 1660 */ 1661 public java.util.List<AssetCategory> findByG_LikeN_V(long groupId, 1662 java.lang.String name, long vocabularyId, int start, int end); 1663 1664 /** 1665 * Returns an ordered range of all the asset categories where groupId = ? and name LIKE ? and vocabularyId = ?. 1666 * 1667 * <p> 1668 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1669 * </p> 1670 * 1671 * @param groupId the group ID 1672 * @param name the name 1673 * @param vocabularyId the vocabulary ID 1674 * @param start the lower bound of the range of asset categories 1675 * @param end the upper bound of the range of asset categories (not inclusive) 1676 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1677 * @return the ordered range of matching asset categories 1678 */ 1679 public java.util.List<AssetCategory> findByG_LikeN_V(long groupId, 1680 java.lang.String name, long vocabularyId, int start, int end, 1681 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1682 1683 /** 1684 * Returns the first asset category in the ordered set where groupId = ? and name LIKE ? and vocabularyId = ?. 1685 * 1686 * @param groupId the group ID 1687 * @param name the name 1688 * @param vocabularyId the vocabulary ID 1689 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1690 * @return the first matching asset category 1691 * @throws NoSuchCategoryException if a matching asset category could not be found 1692 */ 1693 public AssetCategory findByG_LikeN_V_First(long groupId, 1694 java.lang.String name, long vocabularyId, 1695 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 1696 throws com.liferay.portlet.asset.NoSuchCategoryException; 1697 1698 /** 1699 * Returns the first asset category in the ordered set where groupId = ? and name LIKE ? and vocabularyId = ?. 1700 * 1701 * @param groupId the group ID 1702 * @param name the name 1703 * @param vocabularyId the vocabulary ID 1704 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1705 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 1706 */ 1707 public AssetCategory fetchByG_LikeN_V_First(long groupId, 1708 java.lang.String name, long vocabularyId, 1709 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1710 1711 /** 1712 * Returns the last asset category in the ordered set where groupId = ? and name LIKE ? and vocabularyId = ?. 1713 * 1714 * @param groupId the group ID 1715 * @param name the name 1716 * @param vocabularyId the vocabulary ID 1717 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1718 * @return the last matching asset category 1719 * @throws NoSuchCategoryException if a matching asset category could not be found 1720 */ 1721 public AssetCategory findByG_LikeN_V_Last(long groupId, 1722 java.lang.String name, long vocabularyId, 1723 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 1724 throws com.liferay.portlet.asset.NoSuchCategoryException; 1725 1726 /** 1727 * Returns the last asset category in the ordered set where groupId = ? and name LIKE ? and vocabularyId = ?. 1728 * 1729 * @param groupId the group ID 1730 * @param name the name 1731 * @param vocabularyId the vocabulary ID 1732 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1733 * @return the last matching asset category, or <code>null</code> if a matching asset category could not be found 1734 */ 1735 public AssetCategory fetchByG_LikeN_V_Last(long groupId, 1736 java.lang.String name, long vocabularyId, 1737 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1738 1739 /** 1740 * Returns the asset categories before and after the current asset category in the ordered set where groupId = ? and name LIKE ? and vocabularyId = ?. 1741 * 1742 * @param categoryId the primary key of the current asset category 1743 * @param groupId the group ID 1744 * @param name the name 1745 * @param vocabularyId the vocabulary ID 1746 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1747 * @return the previous, current, and next asset category 1748 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 1749 */ 1750 public AssetCategory[] findByG_LikeN_V_PrevAndNext(long categoryId, 1751 long groupId, java.lang.String name, long vocabularyId, 1752 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 1753 throws com.liferay.portlet.asset.NoSuchCategoryException; 1754 1755 /** 1756 * Returns all the asset categories that the user has permission to view where groupId = ? and name LIKE ? and vocabularyId = ?. 1757 * 1758 * @param groupId the group ID 1759 * @param name the name 1760 * @param vocabularyId the vocabulary ID 1761 * @return the matching asset categories that the user has permission to view 1762 */ 1763 public java.util.List<AssetCategory> filterFindByG_LikeN_V(long groupId, 1764 java.lang.String name, long vocabularyId); 1765 1766 /** 1767 * Returns a range of all the asset categories that the user has permission to view where groupId = ? and name LIKE ? and vocabularyId = ?. 1768 * 1769 * <p> 1770 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1771 * </p> 1772 * 1773 * @param groupId the group ID 1774 * @param name the name 1775 * @param vocabularyId the vocabulary ID 1776 * @param start the lower bound of the range of asset categories 1777 * @param end the upper bound of the range of asset categories (not inclusive) 1778 * @return the range of matching asset categories that the user has permission to view 1779 */ 1780 public java.util.List<AssetCategory> filterFindByG_LikeN_V(long groupId, 1781 java.lang.String name, long vocabularyId, int start, int end); 1782 1783 /** 1784 * Returns an ordered range of all the asset categories that the user has permissions to view where groupId = ? and name LIKE ? and vocabularyId = ?. 1785 * 1786 * <p> 1787 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1788 * </p> 1789 * 1790 * @param groupId the group ID 1791 * @param name the name 1792 * @param vocabularyId the vocabulary ID 1793 * @param start the lower bound of the range of asset categories 1794 * @param end the upper bound of the range of asset categories (not inclusive) 1795 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1796 * @return the ordered range of matching asset categories that the user has permission to view 1797 */ 1798 public java.util.List<AssetCategory> filterFindByG_LikeN_V(long groupId, 1799 java.lang.String name, long vocabularyId, int start, int end, 1800 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1801 1802 /** 1803 * Returns the asset categories before and after the current asset category in the ordered set of asset categories that the user has permission to view where groupId = ? and name LIKE ? and vocabularyId = ?. 1804 * 1805 * @param categoryId the primary key of the current asset category 1806 * @param groupId the group ID 1807 * @param name the name 1808 * @param vocabularyId the vocabulary ID 1809 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1810 * @return the previous, current, and next asset category 1811 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 1812 */ 1813 public AssetCategory[] filterFindByG_LikeN_V_PrevAndNext(long categoryId, 1814 long groupId, java.lang.String name, long vocabularyId, 1815 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 1816 throws com.liferay.portlet.asset.NoSuchCategoryException; 1817 1818 /** 1819 * Returns all the asset categories that the user has permission to view where groupId = ? and name LIKE ? and vocabularyId = any ?. 1820 * 1821 * @param groupId the group ID 1822 * @param name the name 1823 * @param vocabularyIds the vocabulary IDs 1824 * @return the matching asset categories that the user has permission to view 1825 */ 1826 public java.util.List<AssetCategory> filterFindByG_LikeN_V(long groupId, 1827 java.lang.String name, long[] vocabularyIds); 1828 1829 /** 1830 * Returns a range of all the asset categories that the user has permission to view where groupId = ? and name LIKE ? and vocabularyId = any ?. 1831 * 1832 * <p> 1833 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1834 * </p> 1835 * 1836 * @param groupId the group ID 1837 * @param name the name 1838 * @param vocabularyIds the vocabulary IDs 1839 * @param start the lower bound of the range of asset categories 1840 * @param end the upper bound of the range of asset categories (not inclusive) 1841 * @return the range of matching asset categories that the user has permission to view 1842 */ 1843 public java.util.List<AssetCategory> filterFindByG_LikeN_V(long groupId, 1844 java.lang.String name, long[] vocabularyIds, int start, int end); 1845 1846 /** 1847 * Returns an ordered range of all the asset categories that the user has permission to view where groupId = ? and name LIKE ? and vocabularyId = any ?. 1848 * 1849 * <p> 1850 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1851 * </p> 1852 * 1853 * @param groupId the group ID 1854 * @param name the name 1855 * @param vocabularyIds the vocabulary IDs 1856 * @param start the lower bound of the range of asset categories 1857 * @param end the upper bound of the range of asset categories (not inclusive) 1858 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1859 * @return the ordered range of matching asset categories that the user has permission to view 1860 */ 1861 public java.util.List<AssetCategory> filterFindByG_LikeN_V(long groupId, 1862 java.lang.String name, long[] vocabularyIds, int start, int end, 1863 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1864 1865 /** 1866 * Returns all the asset categories where groupId = ? and name LIKE ? and vocabularyId = any ?. 1867 * 1868 * <p> 1869 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1870 * </p> 1871 * 1872 * @param groupId the group ID 1873 * @param name the name 1874 * @param vocabularyIds the vocabulary IDs 1875 * @return the matching asset categories 1876 */ 1877 public java.util.List<AssetCategory> findByG_LikeN_V(long groupId, 1878 java.lang.String name, long[] vocabularyIds); 1879 1880 /** 1881 * Returns a range of all the asset categories where groupId = ? and name LIKE ? and vocabularyId = any ?. 1882 * 1883 * <p> 1884 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1885 * </p> 1886 * 1887 * @param groupId the group ID 1888 * @param name the name 1889 * @param vocabularyIds the vocabulary IDs 1890 * @param start the lower bound of the range of asset categories 1891 * @param end the upper bound of the range of asset categories (not inclusive) 1892 * @return the range of matching asset categories 1893 */ 1894 public java.util.List<AssetCategory> findByG_LikeN_V(long groupId, 1895 java.lang.String name, long[] vocabularyIds, int start, int end); 1896 1897 /** 1898 * Returns an ordered range of all the asset categories where groupId = ? and name LIKE ? and vocabularyId = any ?. 1899 * 1900 * <p> 1901 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1902 * </p> 1903 * 1904 * @param groupId the group ID 1905 * @param name the name 1906 * @param vocabularyIds the vocabulary IDs 1907 * @param start the lower bound of the range of asset categories 1908 * @param end the upper bound of the range of asset categories (not inclusive) 1909 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1910 * @return the ordered range of matching asset categories 1911 */ 1912 public java.util.List<AssetCategory> findByG_LikeN_V(long groupId, 1913 java.lang.String name, long[] vocabularyIds, int start, int end, 1914 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 1915 1916 /** 1917 * Removes all the asset categories where groupId = ? and name LIKE ? and vocabularyId = ? from the database. 1918 * 1919 * @param groupId the group ID 1920 * @param name the name 1921 * @param vocabularyId the vocabulary ID 1922 */ 1923 public void removeByG_LikeN_V(long groupId, java.lang.String name, 1924 long vocabularyId); 1925 1926 /** 1927 * Returns the number of asset categories where groupId = ? and name LIKE ? and vocabularyId = ?. 1928 * 1929 * @param groupId the group ID 1930 * @param name the name 1931 * @param vocabularyId the vocabulary ID 1932 * @return the number of matching asset categories 1933 */ 1934 public int countByG_LikeN_V(long groupId, java.lang.String name, 1935 long vocabularyId); 1936 1937 /** 1938 * Returns the number of asset categories where groupId = ? and name LIKE ? and vocabularyId = any ?. 1939 * 1940 * @param groupId the group ID 1941 * @param name the name 1942 * @param vocabularyIds the vocabulary IDs 1943 * @return the number of matching asset categories 1944 */ 1945 public int countByG_LikeN_V(long groupId, java.lang.String name, 1946 long[] vocabularyIds); 1947 1948 /** 1949 * Returns the number of asset categories that the user has permission to view where groupId = ? and name LIKE ? and vocabularyId = ?. 1950 * 1951 * @param groupId the group ID 1952 * @param name the name 1953 * @param vocabularyId the vocabulary ID 1954 * @return the number of matching asset categories that the user has permission to view 1955 */ 1956 public int filterCountByG_LikeN_V(long groupId, java.lang.String name, 1957 long vocabularyId); 1958 1959 /** 1960 * Returns the number of asset categories that the user has permission to view where groupId = ? and name LIKE ? and vocabularyId = any ?. 1961 * 1962 * @param groupId the group ID 1963 * @param name the name 1964 * @param vocabularyIds the vocabulary IDs 1965 * @return the number of matching asset categories that the user has permission to view 1966 */ 1967 public int filterCountByG_LikeN_V(long groupId, java.lang.String name, 1968 long[] vocabularyIds); 1969 1970 /** 1971 * Returns the asset category where parentCategoryId = ? and name = ? and vocabularyId = ? or throws a {@link NoSuchCategoryException} if it could not be found. 1972 * 1973 * @param parentCategoryId the parent category ID 1974 * @param name the name 1975 * @param vocabularyId the vocabulary ID 1976 * @return the matching asset category 1977 * @throws NoSuchCategoryException if a matching asset category could not be found 1978 */ 1979 public AssetCategory findByP_N_V(long parentCategoryId, 1980 java.lang.String name, long vocabularyId) 1981 throws com.liferay.portlet.asset.NoSuchCategoryException; 1982 1983 /** 1984 * 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. 1985 * 1986 * @param parentCategoryId the parent category ID 1987 * @param name the name 1988 * @param vocabularyId the vocabulary ID 1989 * @return the matching asset category, or <code>null</code> if a matching asset category could not be found 1990 */ 1991 public AssetCategory fetchByP_N_V(long parentCategoryId, 1992 java.lang.String name, long vocabularyId); 1993 1994 /** 1995 * 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. 1996 * 1997 * @param parentCategoryId the parent category ID 1998 * @param name the name 1999 * @param vocabularyId the vocabulary ID 2000 * @param retrieveFromCache whether to use the finder cache 2001 * @return the matching asset category, or <code>null</code> if a matching asset category could not be found 2002 */ 2003 public AssetCategory fetchByP_N_V(long parentCategoryId, 2004 java.lang.String name, long vocabularyId, boolean retrieveFromCache); 2005 2006 /** 2007 * Removes the asset category where parentCategoryId = ? and name = ? and vocabularyId = ? from the database. 2008 * 2009 * @param parentCategoryId the parent category ID 2010 * @param name the name 2011 * @param vocabularyId the vocabulary ID 2012 * @return the asset category that was removed 2013 */ 2014 public AssetCategory removeByP_N_V(long parentCategoryId, 2015 java.lang.String name, long vocabularyId) 2016 throws com.liferay.portlet.asset.NoSuchCategoryException; 2017 2018 /** 2019 * Returns the number of asset categories where parentCategoryId = ? and name = ? and vocabularyId = ?. 2020 * 2021 * @param parentCategoryId the parent category ID 2022 * @param name the name 2023 * @param vocabularyId the vocabulary ID 2024 * @return the number of matching asset categories 2025 */ 2026 public int countByP_N_V(long parentCategoryId, java.lang.String name, 2027 long vocabularyId); 2028 2029 /** 2030 * Returns all the asset categories where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2031 * 2032 * @param groupId the group ID 2033 * @param parentCategoryId the parent category ID 2034 * @param name the name 2035 * @param vocabularyId the vocabulary ID 2036 * @return the matching asset categories 2037 */ 2038 public java.util.List<AssetCategory> findByG_P_N_V(long groupId, 2039 long parentCategoryId, java.lang.String name, long vocabularyId); 2040 2041 /** 2042 * Returns a range of all the asset categories where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2043 * 2044 * <p> 2045 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2046 * </p> 2047 * 2048 * @param groupId the group ID 2049 * @param parentCategoryId the parent category ID 2050 * @param name the name 2051 * @param vocabularyId the vocabulary ID 2052 * @param start the lower bound of the range of asset categories 2053 * @param end the upper bound of the range of asset categories (not inclusive) 2054 * @return the range of matching asset categories 2055 */ 2056 public java.util.List<AssetCategory> findByG_P_N_V(long groupId, 2057 long parentCategoryId, java.lang.String name, long vocabularyId, 2058 int start, int end); 2059 2060 /** 2061 * Returns an ordered range of all the asset categories where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2062 * 2063 * <p> 2064 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2065 * </p> 2066 * 2067 * @param groupId the group ID 2068 * @param parentCategoryId the parent category ID 2069 * @param name the name 2070 * @param vocabularyId the vocabulary ID 2071 * @param start the lower bound of the range of asset categories 2072 * @param end the upper bound of the range of asset categories (not inclusive) 2073 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2074 * @return the ordered range of matching asset categories 2075 */ 2076 public java.util.List<AssetCategory> findByG_P_N_V(long groupId, 2077 long parentCategoryId, java.lang.String name, long vocabularyId, 2078 int start, int end, 2079 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 2080 2081 /** 2082 * Returns the first asset category in the ordered set where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2083 * 2084 * @param groupId the group ID 2085 * @param parentCategoryId the parent category ID 2086 * @param name the name 2087 * @param vocabularyId the vocabulary ID 2088 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2089 * @return the first matching asset category 2090 * @throws NoSuchCategoryException if a matching asset category could not be found 2091 */ 2092 public AssetCategory findByG_P_N_V_First(long groupId, 2093 long parentCategoryId, java.lang.String name, long vocabularyId, 2094 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 2095 throws com.liferay.portlet.asset.NoSuchCategoryException; 2096 2097 /** 2098 * Returns the first asset category in the ordered set where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2099 * 2100 * @param groupId the group ID 2101 * @param parentCategoryId the parent category ID 2102 * @param name the name 2103 * @param vocabularyId the vocabulary ID 2104 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2105 * @return the first matching asset category, or <code>null</code> if a matching asset category could not be found 2106 */ 2107 public AssetCategory fetchByG_P_N_V_First(long groupId, 2108 long parentCategoryId, java.lang.String name, long vocabularyId, 2109 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 2110 2111 /** 2112 * Returns the last asset category in the ordered set where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2113 * 2114 * @param groupId the group ID 2115 * @param parentCategoryId the parent category ID 2116 * @param name the name 2117 * @param vocabularyId the vocabulary ID 2118 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2119 * @return the last matching asset category 2120 * @throws NoSuchCategoryException if a matching asset category could not be found 2121 */ 2122 public AssetCategory findByG_P_N_V_Last(long groupId, 2123 long parentCategoryId, java.lang.String name, long vocabularyId, 2124 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 2125 throws com.liferay.portlet.asset.NoSuchCategoryException; 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 */ 2137 public AssetCategory fetchByG_P_N_V_Last(long groupId, 2138 long parentCategoryId, java.lang.String name, long vocabularyId, 2139 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 2140 2141 /** 2142 * Returns the asset categories before and after the current asset category in the ordered set where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2143 * 2144 * @param categoryId the primary key of the current asset category 2145 * @param groupId the group ID 2146 * @param parentCategoryId the parent category ID 2147 * @param name the name 2148 * @param vocabularyId the vocabulary ID 2149 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2150 * @return the previous, current, and next asset category 2151 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 2152 */ 2153 public AssetCategory[] findByG_P_N_V_PrevAndNext(long categoryId, 2154 long groupId, long parentCategoryId, java.lang.String name, 2155 long vocabularyId, 2156 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 2157 throws com.liferay.portlet.asset.NoSuchCategoryException; 2158 2159 /** 2160 * Returns all the asset categories that the user has permission to view where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2161 * 2162 * @param groupId the group ID 2163 * @param parentCategoryId the parent category ID 2164 * @param name the name 2165 * @param vocabularyId the vocabulary ID 2166 * @return the matching asset categories that the user has permission to view 2167 */ 2168 public java.util.List<AssetCategory> filterFindByG_P_N_V(long groupId, 2169 long parentCategoryId, java.lang.String name, long vocabularyId); 2170 2171 /** 2172 * Returns a range of all the asset categories that the user has permission to view where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2173 * 2174 * <p> 2175 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2176 * </p> 2177 * 2178 * @param groupId the group ID 2179 * @param parentCategoryId the parent category ID 2180 * @param name the name 2181 * @param vocabularyId the vocabulary ID 2182 * @param start the lower bound of the range of asset categories 2183 * @param end the upper bound of the range of asset categories (not inclusive) 2184 * @return the range of matching asset categories that the user has permission to view 2185 */ 2186 public java.util.List<AssetCategory> filterFindByG_P_N_V(long groupId, 2187 long parentCategoryId, java.lang.String name, long vocabularyId, 2188 int start, int end); 2189 2190 /** 2191 * Returns an ordered range of all the asset categories that the user has permissions to view where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2192 * 2193 * <p> 2194 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2195 * </p> 2196 * 2197 * @param groupId the group ID 2198 * @param parentCategoryId the parent category ID 2199 * @param name the name 2200 * @param vocabularyId the vocabulary ID 2201 * @param start the lower bound of the range of asset categories 2202 * @param end the upper bound of the range of asset categories (not inclusive) 2203 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2204 * @return the ordered range of matching asset categories that the user has permission to view 2205 */ 2206 public java.util.List<AssetCategory> filterFindByG_P_N_V(long groupId, 2207 long parentCategoryId, java.lang.String name, long vocabularyId, 2208 int start, int end, 2209 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 2210 2211 /** 2212 * 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 = ?. 2213 * 2214 * @param categoryId the primary key of the current asset category 2215 * @param groupId the group ID 2216 * @param parentCategoryId the parent category ID 2217 * @param name the name 2218 * @param vocabularyId the vocabulary ID 2219 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2220 * @return the previous, current, and next asset category 2221 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 2222 */ 2223 public AssetCategory[] filterFindByG_P_N_V_PrevAndNext(long categoryId, 2224 long groupId, long parentCategoryId, java.lang.String name, 2225 long vocabularyId, 2226 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator) 2227 throws com.liferay.portlet.asset.NoSuchCategoryException; 2228 2229 /** 2230 * Removes all the asset categories where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ? from the database. 2231 * 2232 * @param groupId the group ID 2233 * @param parentCategoryId the parent category ID 2234 * @param name the name 2235 * @param vocabularyId the vocabulary ID 2236 */ 2237 public void removeByG_P_N_V(long groupId, long parentCategoryId, 2238 java.lang.String name, long vocabularyId); 2239 2240 /** 2241 * Returns the number of asset categories where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2242 * 2243 * @param groupId the group ID 2244 * @param parentCategoryId the parent category ID 2245 * @param name the name 2246 * @param vocabularyId the vocabulary ID 2247 * @return the number of matching asset categories 2248 */ 2249 public int countByG_P_N_V(long groupId, long parentCategoryId, 2250 java.lang.String name, long vocabularyId); 2251 2252 /** 2253 * Returns the number of asset categories that the user has permission to view where groupId = ? and parentCategoryId = ? and name = ? and vocabularyId = ?. 2254 * 2255 * @param groupId the group ID 2256 * @param parentCategoryId the parent category ID 2257 * @param name the name 2258 * @param vocabularyId the vocabulary ID 2259 * @return the number of matching asset categories that the user has permission to view 2260 */ 2261 public int filterCountByG_P_N_V(long groupId, long parentCategoryId, 2262 java.lang.String name, long vocabularyId); 2263 2264 /** 2265 * Caches the asset category in the entity cache if it is enabled. 2266 * 2267 * @param assetCategory the asset category 2268 */ 2269 public void cacheResult(AssetCategory assetCategory); 2270 2271 /** 2272 * Caches the asset categories in the entity cache if it is enabled. 2273 * 2274 * @param assetCategories the asset categories 2275 */ 2276 public void cacheResult(java.util.List<AssetCategory> assetCategories); 2277 2278 /** 2279 * Creates a new asset category with the primary key. Does not add the asset category to the database. 2280 * 2281 * @param categoryId the primary key for the new asset category 2282 * @return the new asset category 2283 */ 2284 public AssetCategory create(long categoryId); 2285 2286 /** 2287 * Removes the asset category with the primary key from the database. Also notifies the appropriate model listeners. 2288 * 2289 * @param categoryId the primary key of the asset category 2290 * @return the asset category that was removed 2291 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 2292 */ 2293 public AssetCategory remove(long categoryId) 2294 throws com.liferay.portlet.asset.NoSuchCategoryException; 2295 2296 public AssetCategory updateImpl(AssetCategory assetCategory); 2297 2298 /** 2299 * Returns the asset category with the primary key or throws a {@link NoSuchCategoryException} if it could not be found. 2300 * 2301 * @param categoryId the primary key of the asset category 2302 * @return the asset category 2303 * @throws NoSuchCategoryException if a asset category with the primary key could not be found 2304 */ 2305 public AssetCategory findByPrimaryKey(long categoryId) 2306 throws com.liferay.portlet.asset.NoSuchCategoryException; 2307 2308 /** 2309 * Returns the asset category with the primary key or returns <code>null</code> if it could not be found. 2310 * 2311 * @param categoryId the primary key of the asset category 2312 * @return the asset category, or <code>null</code> if a asset category with the primary key could not be found 2313 */ 2314 public AssetCategory fetchByPrimaryKey(long categoryId); 2315 2316 @Override 2317 public java.util.Map<java.io.Serializable, AssetCategory> fetchByPrimaryKeys( 2318 java.util.Set<java.io.Serializable> primaryKeys); 2319 2320 /** 2321 * Returns all the asset categories. 2322 * 2323 * @return the asset categories 2324 */ 2325 public java.util.List<AssetCategory> findAll(); 2326 2327 /** 2328 * Returns a range of all the asset categories. 2329 * 2330 * <p> 2331 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2332 * </p> 2333 * 2334 * @param start the lower bound of the range of asset categories 2335 * @param end the upper bound of the range of asset categories (not inclusive) 2336 * @return the range of asset categories 2337 */ 2338 public java.util.List<AssetCategory> findAll(int start, int end); 2339 2340 /** 2341 * Returns an ordered range of all the asset categories. 2342 * 2343 * <p> 2344 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2345 * </p> 2346 * 2347 * @param start the lower bound of the range of asset categories 2348 * @param end the upper bound of the range of asset categories (not inclusive) 2349 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2350 * @return the ordered range of asset categories 2351 */ 2352 public java.util.List<AssetCategory> findAll(int start, int end, 2353 com.liferay.portal.kernel.util.OrderByComparator<AssetCategory> orderByComparator); 2354 2355 /** 2356 * Removes all the asset categories from the database. 2357 */ 2358 public void removeAll(); 2359 2360 /** 2361 * Returns the number of asset categories. 2362 * 2363 * @return the number of asset categories 2364 */ 2365 public int countAll(); 2366 2367 /** 2368 * Returns the primaryKeys of asset entries associated with the asset category. 2369 * 2370 * @param pk the primary key of the asset category 2371 * @return long[] of the primaryKeys of asset entries associated with the asset category 2372 */ 2373 public long[] getAssetEntryPrimaryKeys(long pk); 2374 2375 /** 2376 * Returns all the asset entries associated with the asset category. 2377 * 2378 * @param pk the primary key of the asset category 2379 * @return the asset entries associated with the asset category 2380 */ 2381 public java.util.List<com.liferay.portlet.asset.model.AssetEntry> getAssetEntries( 2382 long pk); 2383 2384 /** 2385 * Returns a range of all the asset entries associated with the asset category. 2386 * 2387 * <p> 2388 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2389 * </p> 2390 * 2391 * @param pk the primary key of the asset category 2392 * @param start the lower bound of the range of asset categories 2393 * @param end the upper bound of the range of asset categories (not inclusive) 2394 * @return the range of asset entries associated with the asset category 2395 */ 2396 public java.util.List<com.liferay.portlet.asset.model.AssetEntry> getAssetEntries( 2397 long pk, int start, int end); 2398 2399 /** 2400 * Returns an ordered range of all the asset entries associated with the asset category. 2401 * 2402 * <p> 2403 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link QueryUtil#ALL_POS} will return the full result set. If <code>orderByComparator</code> is specified, then the query will include the given ORDER BY logic. If <code>orderByComparator</code> is absent and pagination is required (<code>start</code> and <code>end</code> are not {@link QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link AssetCategoryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 2404 * </p> 2405 * 2406 * @param pk the primary key of the asset category 2407 * @param start the lower bound of the range of asset categories 2408 * @param end the upper bound of the range of asset categories (not inclusive) 2409 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2410 * @return the ordered range of asset entries associated with the asset category 2411 */ 2412 public java.util.List<com.liferay.portlet.asset.model.AssetEntry> getAssetEntries( 2413 long pk, int start, int end, 2414 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portlet.asset.model.AssetEntry> orderByComparator); 2415 2416 /** 2417 * Returns the number of asset entries associated with the asset category. 2418 * 2419 * @param pk the primary key of the asset category 2420 * @return the number of asset entries associated with the asset category 2421 */ 2422 public int getAssetEntriesSize(long pk); 2423 2424 /** 2425 * Returns <code>true</code> if the asset entry is associated with the asset category. 2426 * 2427 * @param pk the primary key of the asset category 2428 * @param assetEntryPK the primary key of the asset entry 2429 * @return <code>true</code> if the asset entry is associated with the asset category; <code>false</code> otherwise 2430 */ 2431 public boolean containsAssetEntry(long pk, long assetEntryPK); 2432 2433 /** 2434 * Returns <code>true</code> if the asset category has any asset entries associated with it. 2435 * 2436 * @param pk the primary key of the asset category to check for associations with asset entries 2437 * @return <code>true</code> if the asset category has any asset entries associated with it; <code>false</code> otherwise 2438 */ 2439 public boolean containsAssetEntries(long pk); 2440 2441 /** 2442 * Adds an association between the asset category and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2443 * 2444 * @param pk the primary key of the asset category 2445 * @param assetEntryPK the primary key of the asset entry 2446 */ 2447 public void addAssetEntry(long pk, long assetEntryPK); 2448 2449 /** 2450 * Adds an association between the asset category and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2451 * 2452 * @param pk the primary key of the asset category 2453 * @param assetEntry the asset entry 2454 */ 2455 public void addAssetEntry(long pk, 2456 com.liferay.portlet.asset.model.AssetEntry assetEntry); 2457 2458 /** 2459 * Adds an association between the asset category and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2460 * 2461 * @param pk the primary key of the asset category 2462 * @param assetEntryPKs the primary keys of the asset entries 2463 */ 2464 public void addAssetEntries(long pk, long[] assetEntryPKs); 2465 2466 /** 2467 * Adds an association between the asset category and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2468 * 2469 * @param pk the primary key of the asset category 2470 * @param assetEntries the asset entries 2471 */ 2472 public void addAssetEntries(long pk, 2473 java.util.List<com.liferay.portlet.asset.model.AssetEntry> assetEntries); 2474 2475 /** 2476 * Clears all associations between the asset category and its asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2477 * 2478 * @param pk the primary key of the asset category to clear the associated asset entries from 2479 */ 2480 public void clearAssetEntries(long pk); 2481 2482 /** 2483 * Removes the association between the asset category and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2484 * 2485 * @param pk the primary key of the asset category 2486 * @param assetEntryPK the primary key of the asset entry 2487 */ 2488 public void removeAssetEntry(long pk, long assetEntryPK); 2489 2490 /** 2491 * Removes the association between the asset category and the asset entry. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2492 * 2493 * @param pk the primary key of the asset category 2494 * @param assetEntry the asset entry 2495 */ 2496 public void removeAssetEntry(long pk, 2497 com.liferay.portlet.asset.model.AssetEntry assetEntry); 2498 2499 /** 2500 * Removes the association between the asset category and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2501 * 2502 * @param pk the primary key of the asset category 2503 * @param assetEntryPKs the primary keys of the asset entries 2504 */ 2505 public void removeAssetEntries(long pk, long[] assetEntryPKs); 2506 2507 /** 2508 * Removes the association between the asset category and the asset entries. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2509 * 2510 * @param pk the primary key of the asset category 2511 * @param assetEntries the asset entries 2512 */ 2513 public void removeAssetEntries(long pk, 2514 java.util.List<com.liferay.portlet.asset.model.AssetEntry> assetEntries); 2515 2516 /** 2517 * 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. 2518 * 2519 * @param pk the primary key of the asset category 2520 * @param assetEntryPKs the primary keys of the asset entries to be associated with the asset category 2521 */ 2522 public void setAssetEntries(long pk, long[] assetEntryPKs); 2523 2524 /** 2525 * 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. 2526 * 2527 * @param pk the primary key of the asset category 2528 * @param assetEntries the asset entries to be associated with the asset category 2529 */ 2530 public void setAssetEntries(long pk, 2531 java.util.List<com.liferay.portlet.asset.model.AssetEntry> assetEntries); 2532 2533 public long countAncestors(AssetCategory assetCategory); 2534 2535 public long countDescendants(AssetCategory assetCategory); 2536 2537 public java.util.List<AssetCategory> getAncestors( 2538 AssetCategory assetCategory); 2539 2540 public java.util.List<AssetCategory> getDescendants( 2541 AssetCategory assetCategory); 2542 2543 /** 2544 * Rebuilds the asset categories tree for the scope using the modified pre-order tree traversal algorithm. 2545 * 2546 * <p> 2547 * 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. 2548 * </p> 2549 * 2550 * @param groupId the ID of the scope 2551 * @param force whether to force the rebuild even if the tree is not stale 2552 */ 2553 public void rebuildTree(long groupId, boolean force); 2554 2555 public void setRebuildTreeEnabled(boolean rebuildTreeEnabled); 2556 }