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