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