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.asset.kernel.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.asset.kernel.model.AssetEntry; 020 021 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 022 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 023 import com.liferay.portal.kernel.service.ServiceContext; 024 import com.liferay.portal.kernel.util.OrderByComparator; 025 import com.liferay.portal.kernel.util.ReferenceRegistry; 026 027 import java.util.Date; 028 import java.util.List; 029 030 /** 031 * The persistence utility for the asset entry service. This utility wraps {@link com.liferay.portlet.asset.service.persistence.impl.AssetEntryPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 032 * 033 * <p> 034 * Caching information and settings can be found in <code>portal.properties</code> 035 * </p> 036 * 037 * @author Brian Wing Shun Chan 038 * @see AssetEntryPersistence 039 * @see com.liferay.portlet.asset.service.persistence.impl.AssetEntryPersistenceImpl 040 * @generated 041 */ 042 @ProviderType 043 public class AssetEntryUtil { 044 /* 045 * NOTE FOR DEVELOPERS: 046 * 047 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 048 */ 049 050 /** 051 * @see com.liferay.portal.kernel.service.persistence.BasePersistence#clearCache() 052 */ 053 public static void clearCache() { 054 getPersistence().clearCache(); 055 } 056 057 /** 058 * @see com.liferay.portal.kernel.service.persistence.BasePersistence#clearCache(com.liferay.portal.kernel.model.BaseModel) 059 */ 060 public static void clearCache(AssetEntry assetEntry) { 061 getPersistence().clearCache(assetEntry); 062 } 063 064 /** 065 * @see com.liferay.portal.kernel.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 066 */ 067 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) { 068 return getPersistence().countWithDynamicQuery(dynamicQuery); 069 } 070 071 /** 072 * @see com.liferay.portal.kernel.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 073 */ 074 public static List<AssetEntry> findWithDynamicQuery( 075 DynamicQuery dynamicQuery) { 076 return getPersistence().findWithDynamicQuery(dynamicQuery); 077 } 078 079 /** 080 * @see com.liferay.portal.kernel.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 081 */ 082 public static List<AssetEntry> findWithDynamicQuery( 083 DynamicQuery dynamicQuery, int start, int end) { 084 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 085 } 086 087 /** 088 * @see com.liferay.portal.kernel.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 089 */ 090 public static List<AssetEntry> findWithDynamicQuery( 091 DynamicQuery dynamicQuery, int start, int end, 092 OrderByComparator<AssetEntry> orderByComparator) { 093 return getPersistence() 094 .findWithDynamicQuery(dynamicQuery, start, end, 095 orderByComparator); 096 } 097 098 /** 099 * @see com.liferay.portal.kernel.service.persistence.BasePersistence#update(com.liferay.portal.kernel.model.BaseModel) 100 */ 101 public static AssetEntry update(AssetEntry assetEntry) { 102 return getPersistence().update(assetEntry); 103 } 104 105 /** 106 * @see com.liferay.portal.kernel.service.persistence.BasePersistence#update(com.liferay.portal.kernel.model.BaseModel, ServiceContext) 107 */ 108 public static AssetEntry update(AssetEntry assetEntry, 109 ServiceContext serviceContext) { 110 return getPersistence().update(assetEntry, serviceContext); 111 } 112 113 /** 114 * Returns all the asset entries where groupId = ?. 115 * 116 * @param groupId the group ID 117 * @return the matching asset entries 118 */ 119 public static List<AssetEntry> findByGroupId(long groupId) { 120 return getPersistence().findByGroupId(groupId); 121 } 122 123 /** 124 * Returns a range of all the asset entries where groupId = ?. 125 * 126 * <p> 127 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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 AssetEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 128 * </p> 129 * 130 * @param groupId the group ID 131 * @param start the lower bound of the range of asset entries 132 * @param end the upper bound of the range of asset entries (not inclusive) 133 * @return the range of matching asset entries 134 */ 135 public static List<AssetEntry> findByGroupId(long groupId, int start, 136 int end) { 137 return getPersistence().findByGroupId(groupId, start, end); 138 } 139 140 /** 141 * Returns an ordered range of all the asset entries where groupId = ?. 142 * 143 * <p> 144 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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 AssetEntryModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 145 * </p> 146 * 147 * @param groupId the group ID 148 * @param start the lower bound of the range of asset entries 149 * @param end the upper bound of the range of asset entries (not inclusive) 150 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 151 * @return the ordered range of matching asset entries 152 */ 153 public static List<AssetEntry> findByGroupId(long groupId, int start, 154 int end, OrderByComparator<AssetEntry> orderByComparator) { 155 return getPersistence() 156 .findByGroupId(groupId, start, end, orderByComparator); 157 } 158 159 /** 160 * Returns an ordered range of all the asset entries where groupId = ?. 161 * 162 * <p> 163 * 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 AssetEntryModelImpl}. 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. 164 * </p> 165 * 166 * @param groupId the group ID 167 * @param start the lower bound of the range of asset entries 168 * @param end the upper bound of the range of asset entries (not inclusive) 169 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 170 * @param retrieveFromCache whether to retrieve from the finder cache 171 * @return the ordered range of matching asset entries 172 */ 173 public static List<AssetEntry> findByGroupId(long groupId, int start, 174 int end, OrderByComparator<AssetEntry> orderByComparator, 175 boolean retrieveFromCache) { 176 return getPersistence() 177 .findByGroupId(groupId, start, end, orderByComparator, 178 retrieveFromCache); 179 } 180 181 /** 182 * Returns the first asset entry in the ordered set where groupId = ?. 183 * 184 * @param groupId the group ID 185 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 186 * @return the first matching asset entry 187 * @throws NoSuchEntryException if a matching asset entry could not be found 188 */ 189 public static AssetEntry findByGroupId_First(long groupId, 190 OrderByComparator<AssetEntry> orderByComparator) 191 throws com.liferay.asset.kernel.exception.NoSuchEntryException { 192 return getPersistence().findByGroupId_First(groupId, orderByComparator); 193 } 194 195 /** 196 * Returns the first asset entry in the ordered set where groupId = ?. 197 * 198 * @param groupId the group ID 199 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 200 * @return the first matching asset entry, or <code>null</code> if a matching asset entry could not be found 201 */ 202 public static AssetEntry fetchByGroupId_First(long groupId, 203 OrderByComparator<AssetEntry> orderByComparator) { 204 return getPersistence().fetchByGroupId_First(groupId, orderByComparator); 205 } 206 207 /** 208 * Returns the last asset entry in the ordered set where groupId = ?. 209 * 210 * @param groupId the group ID 211 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 212 * @return the last matching asset entry 213 * @throws NoSuchEntryException if a matching asset entry could not be found 214 */ 215 public static AssetEntry findByGroupId_Last(long groupId, 216 OrderByComparator<AssetEntry> orderByComparator) 217 throws com.liferay.asset.kernel.exception.NoSuchEntryException { 218 return getPersistence().findByGroupId_Last(groupId, orderByComparator); 219 } 220 221 /** 222 * Returns the last asset entry in the ordered set where groupId = ?. 223 * 224 * @param groupId the group ID 225 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 226 * @return the last matching asset entry, or <code>null</code> if a matching asset entry could not be found 227 */ 228 public static AssetEntry fetchByGroupId_Last(long groupId, 229 OrderByComparator<AssetEntry> orderByComparator) { 230 return getPersistence().fetchByGroupId_Last(groupId, orderByComparator); 231 } 232 233 /** 234 * Returns the asset entries before and after the current asset entry in the ordered set where groupId = ?. 235 * 236 * @param entryId the primary key of the current asset entry 237 * @param groupId the group ID 238 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 239 * @return the previous, current, and next asset entry 240 * @throws NoSuchEntryException if a asset entry with the primary key could not be found 241 */ 242 public static AssetEntry[] findByGroupId_PrevAndNext(long entryId, 243 long groupId, OrderByComparator<AssetEntry> orderByComparator) 244 throws com.liferay.asset.kernel.exception.NoSuchEntryException { 245 return getPersistence() 246 .findByGroupId_PrevAndNext(entryId, groupId, 247 orderByComparator); 248 } 249 250 /** 251 * Removes all the asset entries where groupId = ? from the database. 252 * 253 * @param groupId the group ID 254 */ 255 public static void removeByGroupId(long groupId) { 256 getPersistence().removeByGroupId(groupId); 257 } 258 259 /** 260 * Returns the number of asset entries where groupId = ?. 261 * 262 * @param groupId the group ID 263 * @return the number of matching asset entries 264 */ 265 public static int countByGroupId(long groupId) { 266 return getPersistence().countByGroupId(groupId); 267 } 268 269 /** 270 * Returns all the asset entries where companyId = ?. 271 * 272 * @param companyId the company ID 273 * @return the matching asset entries 274 */ 275 public static List<AssetEntry> findByCompanyId(long companyId) { 276 return getPersistence().findByCompanyId(companyId); 277 } 278 279 /** 280 * Returns a range of all the asset entries where companyId = ?. 281 * 282 * <p> 283 * 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 AssetEntryModelImpl}. 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. 284 * </p> 285 * 286 * @param companyId the company ID 287 * @param start the lower bound of the range of asset entries 288 * @param end the upper bound of the range of asset entries (not inclusive) 289 * @return the range of matching asset entries 290 */ 291 public static List<AssetEntry> findByCompanyId(long companyId, int start, 292 int end) { 293 return getPersistence().findByCompanyId(companyId, start, end); 294 } 295 296 /** 297 * Returns an ordered range of all the asset entries where companyId = ?. 298 * 299 * <p> 300 * 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 AssetEntryModelImpl}. 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. 301 * </p> 302 * 303 * @param companyId the company ID 304 * @param start the lower bound of the range of asset entries 305 * @param end the upper bound of the range of asset entries (not inclusive) 306 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 307 * @return the ordered range of matching asset entries 308 */ 309 public static List<AssetEntry> findByCompanyId(long companyId, int start, 310 int end, OrderByComparator<AssetEntry> orderByComparator) { 311 return getPersistence() 312 .findByCompanyId(companyId, start, end, orderByComparator); 313 } 314 315 /** 316 * Returns an ordered range of all the asset entries where companyId = ?. 317 * 318 * <p> 319 * 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 AssetEntryModelImpl}. 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. 320 * </p> 321 * 322 * @param companyId the company ID 323 * @param start the lower bound of the range of asset entries 324 * @param end the upper bound of the range of asset entries (not inclusive) 325 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 326 * @param retrieveFromCache whether to retrieve from the finder cache 327 * @return the ordered range of matching asset entries 328 */ 329 public static List<AssetEntry> findByCompanyId(long companyId, int start, 330 int end, OrderByComparator<AssetEntry> orderByComparator, 331 boolean retrieveFromCache) { 332 return getPersistence() 333 .findByCompanyId(companyId, start, end, orderByComparator, 334 retrieveFromCache); 335 } 336 337 /** 338 * Returns the first asset entry in the ordered set where companyId = ?. 339 * 340 * @param companyId the company ID 341 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 342 * @return the first matching asset entry 343 * @throws NoSuchEntryException if a matching asset entry could not be found 344 */ 345 public static AssetEntry findByCompanyId_First(long companyId, 346 OrderByComparator<AssetEntry> orderByComparator) 347 throws com.liferay.asset.kernel.exception.NoSuchEntryException { 348 return getPersistence() 349 .findByCompanyId_First(companyId, orderByComparator); 350 } 351 352 /** 353 * Returns the first asset entry in the ordered set where companyId = ?. 354 * 355 * @param companyId the company ID 356 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 357 * @return the first matching asset entry, or <code>null</code> if a matching asset entry could not be found 358 */ 359 public static AssetEntry fetchByCompanyId_First(long companyId, 360 OrderByComparator<AssetEntry> orderByComparator) { 361 return getPersistence() 362 .fetchByCompanyId_First(companyId, orderByComparator); 363 } 364 365 /** 366 * Returns the last asset entry in the ordered set where companyId = ?. 367 * 368 * @param companyId the company ID 369 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 370 * @return the last matching asset entry 371 * @throws NoSuchEntryException if a matching asset entry could not be found 372 */ 373 public static AssetEntry findByCompanyId_Last(long companyId, 374 OrderByComparator<AssetEntry> orderByComparator) 375 throws com.liferay.asset.kernel.exception.NoSuchEntryException { 376 return getPersistence() 377 .findByCompanyId_Last(companyId, orderByComparator); 378 } 379 380 /** 381 * Returns the last asset entry in the ordered set where companyId = ?. 382 * 383 * @param companyId the company ID 384 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 385 * @return the last matching asset entry, or <code>null</code> if a matching asset entry could not be found 386 */ 387 public static AssetEntry fetchByCompanyId_Last(long companyId, 388 OrderByComparator<AssetEntry> orderByComparator) { 389 return getPersistence() 390 .fetchByCompanyId_Last(companyId, orderByComparator); 391 } 392 393 /** 394 * Returns the asset entries before and after the current asset entry in the ordered set where companyId = ?. 395 * 396 * @param entryId the primary key of the current asset entry 397 * @param companyId the company ID 398 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 399 * @return the previous, current, and next asset entry 400 * @throws NoSuchEntryException if a asset entry with the primary key could not be found 401 */ 402 public static AssetEntry[] findByCompanyId_PrevAndNext(long entryId, 403 long companyId, OrderByComparator<AssetEntry> orderByComparator) 404 throws com.liferay.asset.kernel.exception.NoSuchEntryException { 405 return getPersistence() 406 .findByCompanyId_PrevAndNext(entryId, companyId, 407 orderByComparator); 408 } 409 410 /** 411 * Removes all the asset entries where companyId = ? from the database. 412 * 413 * @param companyId the company ID 414 */ 415 public static void removeByCompanyId(long companyId) { 416 getPersistence().removeByCompanyId(companyId); 417 } 418 419 /** 420 * Returns the number of asset entries where companyId = ?. 421 * 422 * @param companyId the company ID 423 * @return the number of matching asset entries 424 */ 425 public static int countByCompanyId(long companyId) { 426 return getPersistence().countByCompanyId(companyId); 427 } 428 429 /** 430 * Returns all the asset entries where visible = ?. 431 * 432 * @param visible the visible 433 * @return the matching asset entries 434 */ 435 public static List<AssetEntry> findByVisible(boolean visible) { 436 return getPersistence().findByVisible(visible); 437 } 438 439 /** 440 * Returns a range of all the asset entries where visible = ?. 441 * 442 * <p> 443 * 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 AssetEntryModelImpl}. 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. 444 * </p> 445 * 446 * @param visible the visible 447 * @param start the lower bound of the range of asset entries 448 * @param end the upper bound of the range of asset entries (not inclusive) 449 * @return the range of matching asset entries 450 */ 451 public static List<AssetEntry> findByVisible(boolean visible, int start, 452 int end) { 453 return getPersistence().findByVisible(visible, start, end); 454 } 455 456 /** 457 * Returns an ordered range of all the asset entries where visible = ?. 458 * 459 * <p> 460 * 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 AssetEntryModelImpl}. 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. 461 * </p> 462 * 463 * @param visible the visible 464 * @param start the lower bound of the range of asset entries 465 * @param end the upper bound of the range of asset entries (not inclusive) 466 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 467 * @return the ordered range of matching asset entries 468 */ 469 public static List<AssetEntry> findByVisible(boolean visible, int start, 470 int end, OrderByComparator<AssetEntry> orderByComparator) { 471 return getPersistence() 472 .findByVisible(visible, start, end, orderByComparator); 473 } 474 475 /** 476 * Returns an ordered range of all the asset entries where visible = ?. 477 * 478 * <p> 479 * 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 AssetEntryModelImpl}. 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. 480 * </p> 481 * 482 * @param visible the visible 483 * @param start the lower bound of the range of asset entries 484 * @param end the upper bound of the range of asset entries (not inclusive) 485 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 486 * @param retrieveFromCache whether to retrieve from the finder cache 487 * @return the ordered range of matching asset entries 488 */ 489 public static List<AssetEntry> findByVisible(boolean visible, int start, 490 int end, OrderByComparator<AssetEntry> orderByComparator, 491 boolean retrieveFromCache) { 492 return getPersistence() 493 .findByVisible(visible, start, end, orderByComparator, 494 retrieveFromCache); 495 } 496 497 /** 498 * Returns the first asset entry in the ordered set where visible = ?. 499 * 500 * @param visible the visible 501 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 502 * @return the first matching asset entry 503 * @throws NoSuchEntryException if a matching asset entry could not be found 504 */ 505 public static AssetEntry findByVisible_First(boolean visible, 506 OrderByComparator<AssetEntry> orderByComparator) 507 throws com.liferay.asset.kernel.exception.NoSuchEntryException { 508 return getPersistence().findByVisible_First(visible, orderByComparator); 509 } 510 511 /** 512 * Returns the first asset entry in the ordered set where visible = ?. 513 * 514 * @param visible the visible 515 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 516 * @return the first matching asset entry, or <code>null</code> if a matching asset entry could not be found 517 */ 518 public static AssetEntry fetchByVisible_First(boolean visible, 519 OrderByComparator<AssetEntry> orderByComparator) { 520 return getPersistence().fetchByVisible_First(visible, orderByComparator); 521 } 522 523 /** 524 * Returns the last asset entry in the ordered set where visible = ?. 525 * 526 * @param visible the visible 527 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 528 * @return the last matching asset entry 529 * @throws NoSuchEntryException if a matching asset entry could not be found 530 */ 531 public static AssetEntry findByVisible_Last(boolean visible, 532 OrderByComparator<AssetEntry> orderByComparator) 533 throws com.liferay.asset.kernel.exception.NoSuchEntryException { 534 return getPersistence().findByVisible_Last(visible, orderByComparator); 535 } 536 537 /** 538 * Returns the last asset entry in the ordered set where visible = ?. 539 * 540 * @param visible the visible 541 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 542 * @return the last matching asset entry, or <code>null</code> if a matching asset entry could not be found 543 */ 544 public static AssetEntry fetchByVisible_Last(boolean visible, 545 OrderByComparator<AssetEntry> orderByComparator) { 546 return getPersistence().fetchByVisible_Last(visible, orderByComparator); 547 } 548 549 /** 550 * Returns the asset entries before and after the current asset entry in the ordered set where visible = ?. 551 * 552 * @param entryId the primary key of the current asset entry 553 * @param visible the visible 554 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 555 * @return the previous, current, and next asset entry 556 * @throws NoSuchEntryException if a asset entry with the primary key could not be found 557 */ 558 public static AssetEntry[] findByVisible_PrevAndNext(long entryId, 559 boolean visible, OrderByComparator<AssetEntry> orderByComparator) 560 throws com.liferay.asset.kernel.exception.NoSuchEntryException { 561 return getPersistence() 562 .findByVisible_PrevAndNext(entryId, visible, 563 orderByComparator); 564 } 565 566 /** 567 * Removes all the asset entries where visible = ? from the database. 568 * 569 * @param visible the visible 570 */ 571 public static void removeByVisible(boolean visible) { 572 getPersistence().removeByVisible(visible); 573 } 574 575 /** 576 * Returns the number of asset entries where visible = ?. 577 * 578 * @param visible the visible 579 * @return the number of matching asset entries 580 */ 581 public static int countByVisible(boolean visible) { 582 return getPersistence().countByVisible(visible); 583 } 584 585 /** 586 * Returns all the asset entries where publishDate = ?. 587 * 588 * @param publishDate the publish date 589 * @return the matching asset entries 590 */ 591 public static List<AssetEntry> findByPublishDate(Date publishDate) { 592 return getPersistence().findByPublishDate(publishDate); 593 } 594 595 /** 596 * Returns a range of all the asset entries where publishDate = ?. 597 * 598 * <p> 599 * 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 AssetEntryModelImpl}. 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. 600 * </p> 601 * 602 * @param publishDate the publish date 603 * @param start the lower bound of the range of asset entries 604 * @param end the upper bound of the range of asset entries (not inclusive) 605 * @return the range of matching asset entries 606 */ 607 public static List<AssetEntry> findByPublishDate(Date publishDate, 608 int start, int end) { 609 return getPersistence().findByPublishDate(publishDate, start, end); 610 } 611 612 /** 613 * Returns an ordered range of all the asset entries where publishDate = ?. 614 * 615 * <p> 616 * 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 AssetEntryModelImpl}. 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. 617 * </p> 618 * 619 * @param publishDate the publish date 620 * @param start the lower bound of the range of asset entries 621 * @param end the upper bound of the range of asset entries (not inclusive) 622 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 623 * @return the ordered range of matching asset entries 624 */ 625 public static List<AssetEntry> findByPublishDate(Date publishDate, 626 int start, int end, OrderByComparator<AssetEntry> orderByComparator) { 627 return getPersistence() 628 .findByPublishDate(publishDate, start, end, orderByComparator); 629 } 630 631 /** 632 * Returns an ordered range of all the asset entries where publishDate = ?. 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 AssetEntryModelImpl}. 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 publishDate the publish date 639 * @param start the lower bound of the range of asset entries 640 * @param end the upper bound of the range of asset entries (not inclusive) 641 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 642 * @param retrieveFromCache whether to retrieve from the finder cache 643 * @return the ordered range of matching asset entries 644 */ 645 public static List<AssetEntry> findByPublishDate(Date publishDate, 646 int start, int end, OrderByComparator<AssetEntry> orderByComparator, 647 boolean retrieveFromCache) { 648 return getPersistence() 649 .findByPublishDate(publishDate, start, end, 650 orderByComparator, retrieveFromCache); 651 } 652 653 /** 654 * Returns the first asset entry in the ordered set where publishDate = ?. 655 * 656 * @param publishDate the publish date 657 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 658 * @return the first matching asset entry 659 * @throws NoSuchEntryException if a matching asset entry could not be found 660 */ 661 public static AssetEntry findByPublishDate_First(Date publishDate, 662 OrderByComparator<AssetEntry> orderByComparator) 663 throws com.liferay.asset.kernel.exception.NoSuchEntryException { 664 return getPersistence() 665 .findByPublishDate_First(publishDate, orderByComparator); 666 } 667 668 /** 669 * Returns the first asset entry in the ordered set where publishDate = ?. 670 * 671 * @param publishDate the publish date 672 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 673 * @return the first matching asset entry, or <code>null</code> if a matching asset entry could not be found 674 */ 675 public static AssetEntry fetchByPublishDate_First(Date publishDate, 676 OrderByComparator<AssetEntry> orderByComparator) { 677 return getPersistence() 678 .fetchByPublishDate_First(publishDate, orderByComparator); 679 } 680 681 /** 682 * Returns the last asset entry in the ordered set where publishDate = ?. 683 * 684 * @param publishDate the publish date 685 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 686 * @return the last matching asset entry 687 * @throws NoSuchEntryException if a matching asset entry could not be found 688 */ 689 public static AssetEntry findByPublishDate_Last(Date publishDate, 690 OrderByComparator<AssetEntry> orderByComparator) 691 throws com.liferay.asset.kernel.exception.NoSuchEntryException { 692 return getPersistence() 693 .findByPublishDate_Last(publishDate, orderByComparator); 694 } 695 696 /** 697 * Returns the last asset entry in the ordered set where publishDate = ?. 698 * 699 * @param publishDate the publish date 700 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 701 * @return the last matching asset entry, or <code>null</code> if a matching asset entry could not be found 702 */ 703 public static AssetEntry fetchByPublishDate_Last(Date publishDate, 704 OrderByComparator<AssetEntry> orderByComparator) { 705 return getPersistence() 706 .fetchByPublishDate_Last(publishDate, orderByComparator); 707 } 708 709 /** 710 * Returns the asset entries before and after the current asset entry in the ordered set where publishDate = ?. 711 * 712 * @param entryId the primary key of the current asset entry 713 * @param publishDate the publish date 714 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 715 * @return the previous, current, and next asset entry 716 * @throws NoSuchEntryException if a asset entry with the primary key could not be found 717 */ 718 public static AssetEntry[] findByPublishDate_PrevAndNext(long entryId, 719 Date publishDate, OrderByComparator<AssetEntry> orderByComparator) 720 throws com.liferay.asset.kernel.exception.NoSuchEntryException { 721 return getPersistence() 722 .findByPublishDate_PrevAndNext(entryId, publishDate, 723 orderByComparator); 724 } 725 726 /** 727 * Removes all the asset entries where publishDate = ? from the database. 728 * 729 * @param publishDate the publish date 730 */ 731 public static void removeByPublishDate(Date publishDate) { 732 getPersistence().removeByPublishDate(publishDate); 733 } 734 735 /** 736 * Returns the number of asset entries where publishDate = ?. 737 * 738 * @param publishDate the publish date 739 * @return the number of matching asset entries 740 */ 741 public static int countByPublishDate(Date publishDate) { 742 return getPersistence().countByPublishDate(publishDate); 743 } 744 745 /** 746 * Returns all the asset entries where expirationDate = ?. 747 * 748 * @param expirationDate the expiration date 749 * @return the matching asset entries 750 */ 751 public static List<AssetEntry> findByExpirationDate(Date expirationDate) { 752 return getPersistence().findByExpirationDate(expirationDate); 753 } 754 755 /** 756 * Returns a range of all the asset entries where expirationDate = ?. 757 * 758 * <p> 759 * 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 AssetEntryModelImpl}. 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. 760 * </p> 761 * 762 * @param expirationDate the expiration date 763 * @param start the lower bound of the range of asset entries 764 * @param end the upper bound of the range of asset entries (not inclusive) 765 * @return the range of matching asset entries 766 */ 767 public static List<AssetEntry> findByExpirationDate(Date expirationDate, 768 int start, int end) { 769 return getPersistence().findByExpirationDate(expirationDate, start, end); 770 } 771 772 /** 773 * Returns an ordered range of all the asset entries where expirationDate = ?. 774 * 775 * <p> 776 * 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 AssetEntryModelImpl}. 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. 777 * </p> 778 * 779 * @param expirationDate the expiration date 780 * @param start the lower bound of the range of asset entries 781 * @param end the upper bound of the range of asset entries (not inclusive) 782 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 783 * @return the ordered range of matching asset entries 784 */ 785 public static List<AssetEntry> findByExpirationDate(Date expirationDate, 786 int start, int end, OrderByComparator<AssetEntry> orderByComparator) { 787 return getPersistence() 788 .findByExpirationDate(expirationDate, start, end, 789 orderByComparator); 790 } 791 792 /** 793 * Returns an ordered range of all the asset entries where expirationDate = ?. 794 * 795 * <p> 796 * 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 AssetEntryModelImpl}. 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. 797 * </p> 798 * 799 * @param expirationDate the expiration date 800 * @param start the lower bound of the range of asset entries 801 * @param end the upper bound of the range of asset entries (not inclusive) 802 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 803 * @param retrieveFromCache whether to retrieve from the finder cache 804 * @return the ordered range of matching asset entries 805 */ 806 public static List<AssetEntry> findByExpirationDate(Date expirationDate, 807 int start, int end, OrderByComparator<AssetEntry> orderByComparator, 808 boolean retrieveFromCache) { 809 return getPersistence() 810 .findByExpirationDate(expirationDate, start, end, 811 orderByComparator, retrieveFromCache); 812 } 813 814 /** 815 * Returns the first asset entry in the ordered set where expirationDate = ?. 816 * 817 * @param expirationDate the expiration date 818 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 819 * @return the first matching asset entry 820 * @throws NoSuchEntryException if a matching asset entry could not be found 821 */ 822 public static AssetEntry findByExpirationDate_First(Date expirationDate, 823 OrderByComparator<AssetEntry> orderByComparator) 824 throws com.liferay.asset.kernel.exception.NoSuchEntryException { 825 return getPersistence() 826 .findByExpirationDate_First(expirationDate, orderByComparator); 827 } 828 829 /** 830 * Returns the first asset entry in the ordered set where expirationDate = ?. 831 * 832 * @param expirationDate the expiration date 833 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 834 * @return the first matching asset entry, or <code>null</code> if a matching asset entry could not be found 835 */ 836 public static AssetEntry fetchByExpirationDate_First(Date expirationDate, 837 OrderByComparator<AssetEntry> orderByComparator) { 838 return getPersistence() 839 .fetchByExpirationDate_First(expirationDate, 840 orderByComparator); 841 } 842 843 /** 844 * Returns the last asset entry in the ordered set where expirationDate = ?. 845 * 846 * @param expirationDate the expiration date 847 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 848 * @return the last matching asset entry 849 * @throws NoSuchEntryException if a matching asset entry could not be found 850 */ 851 public static AssetEntry findByExpirationDate_Last(Date expirationDate, 852 OrderByComparator<AssetEntry> orderByComparator) 853 throws com.liferay.asset.kernel.exception.NoSuchEntryException { 854 return getPersistence() 855 .findByExpirationDate_Last(expirationDate, orderByComparator); 856 } 857 858 /** 859 * Returns the last asset entry in the ordered set where expirationDate = ?. 860 * 861 * @param expirationDate the expiration date 862 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 863 * @return the last matching asset entry, or <code>null</code> if a matching asset entry could not be found 864 */ 865 public static AssetEntry fetchByExpirationDate_Last(Date expirationDate, 866 OrderByComparator<AssetEntry> orderByComparator) { 867 return getPersistence() 868 .fetchByExpirationDate_Last(expirationDate, orderByComparator); 869 } 870 871 /** 872 * Returns the asset entries before and after the current asset entry in the ordered set where expirationDate = ?. 873 * 874 * @param entryId the primary key of the current asset entry 875 * @param expirationDate the expiration date 876 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 877 * @return the previous, current, and next asset entry 878 * @throws NoSuchEntryException if a asset entry with the primary key could not be found 879 */ 880 public static AssetEntry[] findByExpirationDate_PrevAndNext(long entryId, 881 Date expirationDate, OrderByComparator<AssetEntry> orderByComparator) 882 throws com.liferay.asset.kernel.exception.NoSuchEntryException { 883 return getPersistence() 884 .findByExpirationDate_PrevAndNext(entryId, expirationDate, 885 orderByComparator); 886 } 887 888 /** 889 * Removes all the asset entries where expirationDate = ? from the database. 890 * 891 * @param expirationDate the expiration date 892 */ 893 public static void removeByExpirationDate(Date expirationDate) { 894 getPersistence().removeByExpirationDate(expirationDate); 895 } 896 897 /** 898 * Returns the number of asset entries where expirationDate = ?. 899 * 900 * @param expirationDate the expiration date 901 * @return the number of matching asset entries 902 */ 903 public static int countByExpirationDate(Date expirationDate) { 904 return getPersistence().countByExpirationDate(expirationDate); 905 } 906 907 /** 908 * Returns all the asset entries where layoutUuid = ?. 909 * 910 * @param layoutUuid the layout uuid 911 * @return the matching asset entries 912 */ 913 public static List<AssetEntry> findByLayoutUuid(java.lang.String layoutUuid) { 914 return getPersistence().findByLayoutUuid(layoutUuid); 915 } 916 917 /** 918 * Returns a range of all the asset entries where layoutUuid = ?. 919 * 920 * <p> 921 * 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 AssetEntryModelImpl}. 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. 922 * </p> 923 * 924 * @param layoutUuid the layout uuid 925 * @param start the lower bound of the range of asset entries 926 * @param end the upper bound of the range of asset entries (not inclusive) 927 * @return the range of matching asset entries 928 */ 929 public static List<AssetEntry> findByLayoutUuid( 930 java.lang.String layoutUuid, int start, int end) { 931 return getPersistence().findByLayoutUuid(layoutUuid, start, end); 932 } 933 934 /** 935 * Returns an ordered range of all the asset entries where layoutUuid = ?. 936 * 937 * <p> 938 * 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 AssetEntryModelImpl}. 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. 939 * </p> 940 * 941 * @param layoutUuid the layout uuid 942 * @param start the lower bound of the range of asset entries 943 * @param end the upper bound of the range of asset entries (not inclusive) 944 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 945 * @return the ordered range of matching asset entries 946 */ 947 public static List<AssetEntry> findByLayoutUuid( 948 java.lang.String layoutUuid, int start, int end, 949 OrderByComparator<AssetEntry> orderByComparator) { 950 return getPersistence() 951 .findByLayoutUuid(layoutUuid, start, end, orderByComparator); 952 } 953 954 /** 955 * Returns an ordered range of all the asset entries where layoutUuid = ?. 956 * 957 * <p> 958 * 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 AssetEntryModelImpl}. 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. 959 * </p> 960 * 961 * @param layoutUuid the layout uuid 962 * @param start the lower bound of the range of asset entries 963 * @param end the upper bound of the range of asset entries (not inclusive) 964 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 965 * @param retrieveFromCache whether to retrieve from the finder cache 966 * @return the ordered range of matching asset entries 967 */ 968 public static List<AssetEntry> findByLayoutUuid( 969 java.lang.String layoutUuid, int start, int end, 970 OrderByComparator<AssetEntry> orderByComparator, 971 boolean retrieveFromCache) { 972 return getPersistence() 973 .findByLayoutUuid(layoutUuid, start, end, orderByComparator, 974 retrieveFromCache); 975 } 976 977 /** 978 * Returns the first asset entry in the ordered set where layoutUuid = ?. 979 * 980 * @param layoutUuid the layout uuid 981 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 982 * @return the first matching asset entry 983 * @throws NoSuchEntryException if a matching asset entry could not be found 984 */ 985 public static AssetEntry findByLayoutUuid_First( 986 java.lang.String layoutUuid, 987 OrderByComparator<AssetEntry> orderByComparator) 988 throws com.liferay.asset.kernel.exception.NoSuchEntryException { 989 return getPersistence() 990 .findByLayoutUuid_First(layoutUuid, orderByComparator); 991 } 992 993 /** 994 * Returns the first asset entry in the ordered set where layoutUuid = ?. 995 * 996 * @param layoutUuid the layout uuid 997 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 998 * @return the first matching asset entry, or <code>null</code> if a matching asset entry could not be found 999 */ 1000 public static AssetEntry fetchByLayoutUuid_First( 1001 java.lang.String layoutUuid, 1002 OrderByComparator<AssetEntry> orderByComparator) { 1003 return getPersistence() 1004 .fetchByLayoutUuid_First(layoutUuid, orderByComparator); 1005 } 1006 1007 /** 1008 * Returns the last asset entry in the ordered set where layoutUuid = ?. 1009 * 1010 * @param layoutUuid the layout uuid 1011 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1012 * @return the last matching asset entry 1013 * @throws NoSuchEntryException if a matching asset entry could not be found 1014 */ 1015 public static AssetEntry findByLayoutUuid_Last( 1016 java.lang.String layoutUuid, 1017 OrderByComparator<AssetEntry> orderByComparator) 1018 throws com.liferay.asset.kernel.exception.NoSuchEntryException { 1019 return getPersistence() 1020 .findByLayoutUuid_Last(layoutUuid, orderByComparator); 1021 } 1022 1023 /** 1024 * Returns the last asset entry in the ordered set where layoutUuid = ?. 1025 * 1026 * @param layoutUuid the layout uuid 1027 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1028 * @return the last matching asset entry, or <code>null</code> if a matching asset entry could not be found 1029 */ 1030 public static AssetEntry fetchByLayoutUuid_Last( 1031 java.lang.String layoutUuid, 1032 OrderByComparator<AssetEntry> orderByComparator) { 1033 return getPersistence() 1034 .fetchByLayoutUuid_Last(layoutUuid, orderByComparator); 1035 } 1036 1037 /** 1038 * Returns the asset entries before and after the current asset entry in the ordered set where layoutUuid = ?. 1039 * 1040 * @param entryId the primary key of the current asset entry 1041 * @param layoutUuid the layout uuid 1042 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1043 * @return the previous, current, and next asset entry 1044 * @throws NoSuchEntryException if a asset entry with the primary key could not be found 1045 */ 1046 public static AssetEntry[] findByLayoutUuid_PrevAndNext(long entryId, 1047 java.lang.String layoutUuid, 1048 OrderByComparator<AssetEntry> orderByComparator) 1049 throws com.liferay.asset.kernel.exception.NoSuchEntryException { 1050 return getPersistence() 1051 .findByLayoutUuid_PrevAndNext(entryId, layoutUuid, 1052 orderByComparator); 1053 } 1054 1055 /** 1056 * Removes all the asset entries where layoutUuid = ? from the database. 1057 * 1058 * @param layoutUuid the layout uuid 1059 */ 1060 public static void removeByLayoutUuid(java.lang.String layoutUuid) { 1061 getPersistence().removeByLayoutUuid(layoutUuid); 1062 } 1063 1064 /** 1065 * Returns the number of asset entries where layoutUuid = ?. 1066 * 1067 * @param layoutUuid the layout uuid 1068 * @return the number of matching asset entries 1069 */ 1070 public static int countByLayoutUuid(java.lang.String layoutUuid) { 1071 return getPersistence().countByLayoutUuid(layoutUuid); 1072 } 1073 1074 /** 1075 * Returns the asset entry where groupId = ? and classUuid = ? or throws a {@link NoSuchEntryException} if it could not be found. 1076 * 1077 * @param groupId the group ID 1078 * @param classUuid the class uuid 1079 * @return the matching asset entry 1080 * @throws NoSuchEntryException if a matching asset entry could not be found 1081 */ 1082 public static AssetEntry findByG_CU(long groupId, java.lang.String classUuid) 1083 throws com.liferay.asset.kernel.exception.NoSuchEntryException { 1084 return getPersistence().findByG_CU(groupId, classUuid); 1085 } 1086 1087 /** 1088 * Returns the asset entry where groupId = ? and classUuid = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 1089 * 1090 * @param groupId the group ID 1091 * @param classUuid the class uuid 1092 * @return the matching asset entry, or <code>null</code> if a matching asset entry could not be found 1093 */ 1094 public static AssetEntry fetchByG_CU(long groupId, 1095 java.lang.String classUuid) { 1096 return getPersistence().fetchByG_CU(groupId, classUuid); 1097 } 1098 1099 /** 1100 * Returns the asset entry where groupId = ? and classUuid = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 1101 * 1102 * @param groupId the group ID 1103 * @param classUuid the class uuid 1104 * @param retrieveFromCache whether to retrieve from the finder cache 1105 * @return the matching asset entry, or <code>null</code> if a matching asset entry could not be found 1106 */ 1107 public static AssetEntry fetchByG_CU(long groupId, 1108 java.lang.String classUuid, boolean retrieveFromCache) { 1109 return getPersistence() 1110 .fetchByG_CU(groupId, classUuid, retrieveFromCache); 1111 } 1112 1113 /** 1114 * Removes the asset entry where groupId = ? and classUuid = ? from the database. 1115 * 1116 * @param groupId the group ID 1117 * @param classUuid the class uuid 1118 * @return the asset entry that was removed 1119 */ 1120 public static AssetEntry removeByG_CU(long groupId, 1121 java.lang.String classUuid) 1122 throws com.liferay.asset.kernel.exception.NoSuchEntryException { 1123 return getPersistence().removeByG_CU(groupId, classUuid); 1124 } 1125 1126 /** 1127 * Returns the number of asset entries where groupId = ? and classUuid = ?. 1128 * 1129 * @param groupId the group ID 1130 * @param classUuid the class uuid 1131 * @return the number of matching asset entries 1132 */ 1133 public static int countByG_CU(long groupId, java.lang.String classUuid) { 1134 return getPersistence().countByG_CU(groupId, classUuid); 1135 } 1136 1137 /** 1138 * Returns the asset entry where classNameId = ? and classPK = ? or throws a {@link NoSuchEntryException} if it could not be found. 1139 * 1140 * @param classNameId the class name ID 1141 * @param classPK the class p k 1142 * @return the matching asset entry 1143 * @throws NoSuchEntryException if a matching asset entry could not be found 1144 */ 1145 public static AssetEntry findByC_C(long classNameId, long classPK) 1146 throws com.liferay.asset.kernel.exception.NoSuchEntryException { 1147 return getPersistence().findByC_C(classNameId, classPK); 1148 } 1149 1150 /** 1151 * Returns the asset entry where classNameId = ? and classPK = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 1152 * 1153 * @param classNameId the class name ID 1154 * @param classPK the class p k 1155 * @return the matching asset entry, or <code>null</code> if a matching asset entry could not be found 1156 */ 1157 public static AssetEntry fetchByC_C(long classNameId, long classPK) { 1158 return getPersistence().fetchByC_C(classNameId, classPK); 1159 } 1160 1161 /** 1162 * Returns the asset entry where classNameId = ? and classPK = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 1163 * 1164 * @param classNameId the class name ID 1165 * @param classPK the class p k 1166 * @param retrieveFromCache whether to retrieve from the finder cache 1167 * @return the matching asset entry, or <code>null</code> if a matching asset entry could not be found 1168 */ 1169 public static AssetEntry fetchByC_C(long classNameId, long classPK, 1170 boolean retrieveFromCache) { 1171 return getPersistence() 1172 .fetchByC_C(classNameId, classPK, retrieveFromCache); 1173 } 1174 1175 /** 1176 * Removes the asset entry where classNameId = ? and classPK = ? from the database. 1177 * 1178 * @param classNameId the class name ID 1179 * @param classPK the class p k 1180 * @return the asset entry that was removed 1181 */ 1182 public static AssetEntry removeByC_C(long classNameId, long classPK) 1183 throws com.liferay.asset.kernel.exception.NoSuchEntryException { 1184 return getPersistence().removeByC_C(classNameId, classPK); 1185 } 1186 1187 /** 1188 * Returns the number of asset entries where classNameId = ? and classPK = ?. 1189 * 1190 * @param classNameId the class name ID 1191 * @param classPK the class p k 1192 * @return the number of matching asset entries 1193 */ 1194 public static int countByC_C(long classNameId, long classPK) { 1195 return getPersistence().countByC_C(classNameId, classPK); 1196 } 1197 1198 /** 1199 * Caches the asset entry in the entity cache if it is enabled. 1200 * 1201 * @param assetEntry the asset entry 1202 */ 1203 public static void cacheResult(AssetEntry assetEntry) { 1204 getPersistence().cacheResult(assetEntry); 1205 } 1206 1207 /** 1208 * Caches the asset entries in the entity cache if it is enabled. 1209 * 1210 * @param assetEntries the asset entries 1211 */ 1212 public static void cacheResult(List<AssetEntry> assetEntries) { 1213 getPersistence().cacheResult(assetEntries); 1214 } 1215 1216 /** 1217 * Creates a new asset entry with the primary key. Does not add the asset entry to the database. 1218 * 1219 * @param entryId the primary key for the new asset entry 1220 * @return the new asset entry 1221 */ 1222 public static AssetEntry create(long entryId) { 1223 return getPersistence().create(entryId); 1224 } 1225 1226 /** 1227 * Removes the asset entry with the primary key from the database. Also notifies the appropriate model listeners. 1228 * 1229 * @param entryId the primary key of the asset entry 1230 * @return the asset entry that was removed 1231 * @throws NoSuchEntryException if a asset entry with the primary key could not be found 1232 */ 1233 public static AssetEntry remove(long entryId) 1234 throws com.liferay.asset.kernel.exception.NoSuchEntryException { 1235 return getPersistence().remove(entryId); 1236 } 1237 1238 public static AssetEntry updateImpl(AssetEntry assetEntry) { 1239 return getPersistence().updateImpl(assetEntry); 1240 } 1241 1242 /** 1243 * Returns the asset entry with the primary key or throws a {@link NoSuchEntryException} if it could not be found. 1244 * 1245 * @param entryId the primary key of the asset entry 1246 * @return the asset entry 1247 * @throws NoSuchEntryException if a asset entry with the primary key could not be found 1248 */ 1249 public static AssetEntry findByPrimaryKey(long entryId) 1250 throws com.liferay.asset.kernel.exception.NoSuchEntryException { 1251 return getPersistence().findByPrimaryKey(entryId); 1252 } 1253 1254 /** 1255 * Returns the asset entry with the primary key or returns <code>null</code> if it could not be found. 1256 * 1257 * @param entryId the primary key of the asset entry 1258 * @return the asset entry, or <code>null</code> if a asset entry with the primary key could not be found 1259 */ 1260 public static AssetEntry fetchByPrimaryKey(long entryId) { 1261 return getPersistence().fetchByPrimaryKey(entryId); 1262 } 1263 1264 public static java.util.Map<java.io.Serializable, AssetEntry> fetchByPrimaryKeys( 1265 java.util.Set<java.io.Serializable> primaryKeys) { 1266 return getPersistence().fetchByPrimaryKeys(primaryKeys); 1267 } 1268 1269 /** 1270 * Returns all the asset entries. 1271 * 1272 * @return the asset entries 1273 */ 1274 public static List<AssetEntry> findAll() { 1275 return getPersistence().findAll(); 1276 } 1277 1278 /** 1279 * Returns a range of all the asset entries. 1280 * 1281 * <p> 1282 * 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 AssetEntryModelImpl}. 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. 1283 * </p> 1284 * 1285 * @param start the lower bound of the range of asset entries 1286 * @param end the upper bound of the range of asset entries (not inclusive) 1287 * @return the range of asset entries 1288 */ 1289 public static List<AssetEntry> findAll(int start, int end) { 1290 return getPersistence().findAll(start, end); 1291 } 1292 1293 /** 1294 * Returns an ordered range of all the asset entries. 1295 * 1296 * <p> 1297 * 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 AssetEntryModelImpl}. 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. 1298 * </p> 1299 * 1300 * @param start the lower bound of the range of asset entries 1301 * @param end the upper bound of the range of asset entries (not inclusive) 1302 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1303 * @return the ordered range of asset entries 1304 */ 1305 public static List<AssetEntry> findAll(int start, int end, 1306 OrderByComparator<AssetEntry> orderByComparator) { 1307 return getPersistence().findAll(start, end, orderByComparator); 1308 } 1309 1310 /** 1311 * Returns an ordered range of all the asset entries. 1312 * 1313 * <p> 1314 * 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 AssetEntryModelImpl}. 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. 1315 * </p> 1316 * 1317 * @param start the lower bound of the range of asset entries 1318 * @param end the upper bound of the range of asset entries (not inclusive) 1319 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1320 * @param retrieveFromCache whether to retrieve from the finder cache 1321 * @return the ordered range of asset entries 1322 */ 1323 public static List<AssetEntry> findAll(int start, int end, 1324 OrderByComparator<AssetEntry> orderByComparator, 1325 boolean retrieveFromCache) { 1326 return getPersistence() 1327 .findAll(start, end, orderByComparator, retrieveFromCache); 1328 } 1329 1330 /** 1331 * Removes all the asset entries from the database. 1332 */ 1333 public static void removeAll() { 1334 getPersistence().removeAll(); 1335 } 1336 1337 /** 1338 * Returns the number of asset entries. 1339 * 1340 * @return the number of asset entries 1341 */ 1342 public static int countAll() { 1343 return getPersistence().countAll(); 1344 } 1345 1346 /** 1347 * Returns the primaryKeys of asset categories associated with the asset entry. 1348 * 1349 * @param pk the primary key of the asset entry 1350 * @return long[] of the primaryKeys of asset categories associated with the asset entry 1351 */ 1352 public static long[] getAssetCategoryPrimaryKeys(long pk) { 1353 return getPersistence().getAssetCategoryPrimaryKeys(pk); 1354 } 1355 1356 /** 1357 * Returns all the asset categories associated with the asset entry. 1358 * 1359 * @param pk the primary key of the asset entry 1360 * @return the asset categories associated with the asset entry 1361 */ 1362 public static List<com.liferay.asset.kernel.model.AssetCategory> getAssetCategories( 1363 long pk) { 1364 return getPersistence().getAssetCategories(pk); 1365 } 1366 1367 /** 1368 * Returns a range of all the asset categories associated with the asset entry. 1369 * 1370 * <p> 1371 * 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 AssetEntryModelImpl}. 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. 1372 * </p> 1373 * 1374 * @param pk the primary key of the asset entry 1375 * @param start the lower bound of the range of asset entries 1376 * @param end the upper bound of the range of asset entries (not inclusive) 1377 * @return the range of asset categories associated with the asset entry 1378 */ 1379 public static List<com.liferay.asset.kernel.model.AssetCategory> getAssetCategories( 1380 long pk, int start, int end) { 1381 return getPersistence().getAssetCategories(pk, start, end); 1382 } 1383 1384 /** 1385 * Returns an ordered range of all the asset categories associated with the asset entry. 1386 * 1387 * <p> 1388 * 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 AssetEntryModelImpl}. 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. 1389 * </p> 1390 * 1391 * @param pk the primary key of the asset entry 1392 * @param start the lower bound of the range of asset entries 1393 * @param end the upper bound of the range of asset entries (not inclusive) 1394 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1395 * @return the ordered range of asset categories associated with the asset entry 1396 */ 1397 public static List<com.liferay.asset.kernel.model.AssetCategory> getAssetCategories( 1398 long pk, int start, int end, 1399 OrderByComparator<com.liferay.asset.kernel.model.AssetCategory> orderByComparator) { 1400 return getPersistence() 1401 .getAssetCategories(pk, start, end, orderByComparator); 1402 } 1403 1404 /** 1405 * Returns the number of asset categories associated with the asset entry. 1406 * 1407 * @param pk the primary key of the asset entry 1408 * @return the number of asset categories associated with the asset entry 1409 */ 1410 public static int getAssetCategoriesSize(long pk) { 1411 return getPersistence().getAssetCategoriesSize(pk); 1412 } 1413 1414 /** 1415 * Returns <code>true</code> if the asset category is associated with the asset entry. 1416 * 1417 * @param pk the primary key of the asset entry 1418 * @param assetCategoryPK the primary key of the asset category 1419 * @return <code>true</code> if the asset category is associated with the asset entry; <code>false</code> otherwise 1420 */ 1421 public static boolean containsAssetCategory(long pk, long assetCategoryPK) { 1422 return getPersistence().containsAssetCategory(pk, assetCategoryPK); 1423 } 1424 1425 /** 1426 * Returns <code>true</code> if the asset entry has any asset categories associated with it. 1427 * 1428 * @param pk the primary key of the asset entry to check for associations with asset categories 1429 * @return <code>true</code> if the asset entry has any asset categories associated with it; <code>false</code> otherwise 1430 */ 1431 public static boolean containsAssetCategories(long pk) { 1432 return getPersistence().containsAssetCategories(pk); 1433 } 1434 1435 /** 1436 * Adds an association between the asset entry and the asset category. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1437 * 1438 * @param pk the primary key of the asset entry 1439 * @param assetCategoryPK the primary key of the asset category 1440 */ 1441 public static void addAssetCategory(long pk, long assetCategoryPK) { 1442 getPersistence().addAssetCategory(pk, assetCategoryPK); 1443 } 1444 1445 /** 1446 * Adds an association between the asset entry and the asset category. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1447 * 1448 * @param pk the primary key of the asset entry 1449 * @param assetCategory the asset category 1450 */ 1451 public static void addAssetCategory(long pk, 1452 com.liferay.asset.kernel.model.AssetCategory assetCategory) { 1453 getPersistence().addAssetCategory(pk, assetCategory); 1454 } 1455 1456 /** 1457 * Adds an association between the asset entry and the asset categories. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1458 * 1459 * @param pk the primary key of the asset entry 1460 * @param assetCategoryPKs the primary keys of the asset categories 1461 */ 1462 public static void addAssetCategories(long pk, long[] assetCategoryPKs) { 1463 getPersistence().addAssetCategories(pk, assetCategoryPKs); 1464 } 1465 1466 /** 1467 * Adds an association between the asset entry and the asset categories. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1468 * 1469 * @param pk the primary key of the asset entry 1470 * @param assetCategories the asset categories 1471 */ 1472 public static void addAssetCategories(long pk, 1473 List<com.liferay.asset.kernel.model.AssetCategory> assetCategories) { 1474 getPersistence().addAssetCategories(pk, assetCategories); 1475 } 1476 1477 /** 1478 * Clears all associations between the asset entry and its asset categories. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1479 * 1480 * @param pk the primary key of the asset entry to clear the associated asset categories from 1481 */ 1482 public static void clearAssetCategories(long pk) { 1483 getPersistence().clearAssetCategories(pk); 1484 } 1485 1486 /** 1487 * Removes the association between the asset entry and the asset category. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1488 * 1489 * @param pk the primary key of the asset entry 1490 * @param assetCategoryPK the primary key of the asset category 1491 */ 1492 public static void removeAssetCategory(long pk, long assetCategoryPK) { 1493 getPersistence().removeAssetCategory(pk, assetCategoryPK); 1494 } 1495 1496 /** 1497 * Removes the association between the asset entry and the asset category. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1498 * 1499 * @param pk the primary key of the asset entry 1500 * @param assetCategory the asset category 1501 */ 1502 public static void removeAssetCategory(long pk, 1503 com.liferay.asset.kernel.model.AssetCategory assetCategory) { 1504 getPersistence().removeAssetCategory(pk, assetCategory); 1505 } 1506 1507 /** 1508 * Removes the association between the asset entry and the asset categories. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1509 * 1510 * @param pk the primary key of the asset entry 1511 * @param assetCategoryPKs the primary keys of the asset categories 1512 */ 1513 public static void removeAssetCategories(long pk, long[] assetCategoryPKs) { 1514 getPersistence().removeAssetCategories(pk, assetCategoryPKs); 1515 } 1516 1517 /** 1518 * Removes the association between the asset entry and the asset categories. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1519 * 1520 * @param pk the primary key of the asset entry 1521 * @param assetCategories the asset categories 1522 */ 1523 public static void removeAssetCategories(long pk, 1524 List<com.liferay.asset.kernel.model.AssetCategory> assetCategories) { 1525 getPersistence().removeAssetCategories(pk, assetCategories); 1526 } 1527 1528 /** 1529 * Sets the asset categories associated with the asset entry, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1530 * 1531 * @param pk the primary key of the asset entry 1532 * @param assetCategoryPKs the primary keys of the asset categories to be associated with the asset entry 1533 */ 1534 public static void setAssetCategories(long pk, long[] assetCategoryPKs) { 1535 getPersistence().setAssetCategories(pk, assetCategoryPKs); 1536 } 1537 1538 /** 1539 * Sets the asset categories associated with the asset entry, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1540 * 1541 * @param pk the primary key of the asset entry 1542 * @param assetCategories the asset categories to be associated with the asset entry 1543 */ 1544 public static void setAssetCategories(long pk, 1545 List<com.liferay.asset.kernel.model.AssetCategory> assetCategories) { 1546 getPersistence().setAssetCategories(pk, assetCategories); 1547 } 1548 1549 /** 1550 * Returns the primaryKeys of asset tags associated with the asset entry. 1551 * 1552 * @param pk the primary key of the asset entry 1553 * @return long[] of the primaryKeys of asset tags associated with the asset entry 1554 */ 1555 public static long[] getAssetTagPrimaryKeys(long pk) { 1556 return getPersistence().getAssetTagPrimaryKeys(pk); 1557 } 1558 1559 /** 1560 * Returns all the asset tags associated with the asset entry. 1561 * 1562 * @param pk the primary key of the asset entry 1563 * @return the asset tags associated with the asset entry 1564 */ 1565 public static List<com.liferay.asset.kernel.model.AssetTag> getAssetTags( 1566 long pk) { 1567 return getPersistence().getAssetTags(pk); 1568 } 1569 1570 /** 1571 * Returns a range of all the asset tags associated with the asset entry. 1572 * 1573 * <p> 1574 * 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 AssetEntryModelImpl}. 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. 1575 * </p> 1576 * 1577 * @param pk the primary key of the asset entry 1578 * @param start the lower bound of the range of asset entries 1579 * @param end the upper bound of the range of asset entries (not inclusive) 1580 * @return the range of asset tags associated with the asset entry 1581 */ 1582 public static List<com.liferay.asset.kernel.model.AssetTag> getAssetTags( 1583 long pk, int start, int end) { 1584 return getPersistence().getAssetTags(pk, start, end); 1585 } 1586 1587 /** 1588 * Returns an ordered range of all the asset tags associated with the asset entry. 1589 * 1590 * <p> 1591 * 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 AssetEntryModelImpl}. 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. 1592 * </p> 1593 * 1594 * @param pk the primary key of the asset entry 1595 * @param start the lower bound of the range of asset entries 1596 * @param end the upper bound of the range of asset entries (not inclusive) 1597 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1598 * @return the ordered range of asset tags associated with the asset entry 1599 */ 1600 public static List<com.liferay.asset.kernel.model.AssetTag> getAssetTags( 1601 long pk, int start, int end, 1602 OrderByComparator<com.liferay.asset.kernel.model.AssetTag> orderByComparator) { 1603 return getPersistence().getAssetTags(pk, start, end, orderByComparator); 1604 } 1605 1606 /** 1607 * Returns the number of asset tags associated with the asset entry. 1608 * 1609 * @param pk the primary key of the asset entry 1610 * @return the number of asset tags associated with the asset entry 1611 */ 1612 public static int getAssetTagsSize(long pk) { 1613 return getPersistence().getAssetTagsSize(pk); 1614 } 1615 1616 /** 1617 * Returns <code>true</code> if the asset tag is associated with the asset entry. 1618 * 1619 * @param pk the primary key of the asset entry 1620 * @param assetTagPK the primary key of the asset tag 1621 * @return <code>true</code> if the asset tag is associated with the asset entry; <code>false</code> otherwise 1622 */ 1623 public static boolean containsAssetTag(long pk, long assetTagPK) { 1624 return getPersistence().containsAssetTag(pk, assetTagPK); 1625 } 1626 1627 /** 1628 * Returns <code>true</code> if the asset entry has any asset tags associated with it. 1629 * 1630 * @param pk the primary key of the asset entry to check for associations with asset tags 1631 * @return <code>true</code> if the asset entry has any asset tags associated with it; <code>false</code> otherwise 1632 */ 1633 public static boolean containsAssetTags(long pk) { 1634 return getPersistence().containsAssetTags(pk); 1635 } 1636 1637 /** 1638 * Adds an association between the asset entry and the asset tag. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1639 * 1640 * @param pk the primary key of the asset entry 1641 * @param assetTagPK the primary key of the asset tag 1642 */ 1643 public static void addAssetTag(long pk, long assetTagPK) { 1644 getPersistence().addAssetTag(pk, assetTagPK); 1645 } 1646 1647 /** 1648 * Adds an association between the asset entry and the asset tag. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1649 * 1650 * @param pk the primary key of the asset entry 1651 * @param assetTag the asset tag 1652 */ 1653 public static void addAssetTag(long pk, 1654 com.liferay.asset.kernel.model.AssetTag assetTag) { 1655 getPersistence().addAssetTag(pk, assetTag); 1656 } 1657 1658 /** 1659 * Adds an association between the asset entry and the asset tags. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1660 * 1661 * @param pk the primary key of the asset entry 1662 * @param assetTagPKs the primary keys of the asset tags 1663 */ 1664 public static void addAssetTags(long pk, long[] assetTagPKs) { 1665 getPersistence().addAssetTags(pk, assetTagPKs); 1666 } 1667 1668 /** 1669 * Adds an association between the asset entry and the asset tags. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1670 * 1671 * @param pk the primary key of the asset entry 1672 * @param assetTags the asset tags 1673 */ 1674 public static void addAssetTags(long pk, 1675 List<com.liferay.asset.kernel.model.AssetTag> assetTags) { 1676 getPersistence().addAssetTags(pk, assetTags); 1677 } 1678 1679 /** 1680 * Clears all associations between the asset entry and its asset tags. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1681 * 1682 * @param pk the primary key of the asset entry to clear the associated asset tags from 1683 */ 1684 public static void clearAssetTags(long pk) { 1685 getPersistence().clearAssetTags(pk); 1686 } 1687 1688 /** 1689 * Removes the association between the asset entry and the asset tag. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1690 * 1691 * @param pk the primary key of the asset entry 1692 * @param assetTagPK the primary key of the asset tag 1693 */ 1694 public static void removeAssetTag(long pk, long assetTagPK) { 1695 getPersistence().removeAssetTag(pk, assetTagPK); 1696 } 1697 1698 /** 1699 * Removes the association between the asset entry and the asset tag. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1700 * 1701 * @param pk the primary key of the asset entry 1702 * @param assetTag the asset tag 1703 */ 1704 public static void removeAssetTag(long pk, 1705 com.liferay.asset.kernel.model.AssetTag assetTag) { 1706 getPersistence().removeAssetTag(pk, assetTag); 1707 } 1708 1709 /** 1710 * Removes the association between the asset entry and the asset tags. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1711 * 1712 * @param pk the primary key of the asset entry 1713 * @param assetTagPKs the primary keys of the asset tags 1714 */ 1715 public static void removeAssetTags(long pk, long[] assetTagPKs) { 1716 getPersistence().removeAssetTags(pk, assetTagPKs); 1717 } 1718 1719 /** 1720 * Removes the association between the asset entry and the asset tags. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1721 * 1722 * @param pk the primary key of the asset entry 1723 * @param assetTags the asset tags 1724 */ 1725 public static void removeAssetTags(long pk, 1726 List<com.liferay.asset.kernel.model.AssetTag> assetTags) { 1727 getPersistence().removeAssetTags(pk, assetTags); 1728 } 1729 1730 /** 1731 * Sets the asset tags associated with the asset entry, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1732 * 1733 * @param pk the primary key of the asset entry 1734 * @param assetTagPKs the primary keys of the asset tags to be associated with the asset entry 1735 */ 1736 public static void setAssetTags(long pk, long[] assetTagPKs) { 1737 getPersistence().setAssetTags(pk, assetTagPKs); 1738 } 1739 1740 /** 1741 * Sets the asset tags associated with the asset entry, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1742 * 1743 * @param pk the primary key of the asset entry 1744 * @param assetTags the asset tags to be associated with the asset entry 1745 */ 1746 public static void setAssetTags(long pk, 1747 List<com.liferay.asset.kernel.model.AssetTag> assetTags) { 1748 getPersistence().setAssetTags(pk, assetTags); 1749 } 1750 1751 public static AssetEntryPersistence getPersistence() { 1752 if (_persistence == null) { 1753 _persistence = (AssetEntryPersistence)PortalBeanLocatorUtil.locate(AssetEntryPersistence.class.getName()); 1754 1755 ReferenceRegistry.registerReference(AssetEntryUtil.class, 1756 "_persistence"); 1757 } 1758 1759 return _persistence; 1760 } 1761 1762 private static AssetEntryPersistence _persistence; 1763 }