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