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