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.portal.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.exception.NoSuchTeamException; 020 import com.liferay.portal.model.Team; 021 022 /** 023 * The persistence interface for the team service. 024 * 025 * <p> 026 * Caching information and settings can be found in <code>portal.properties</code> 027 * </p> 028 * 029 * @author Brian Wing Shun Chan 030 * @see com.liferay.portal.service.persistence.impl.TeamPersistenceImpl 031 * @see TeamUtil 032 * @generated 033 */ 034 @ProviderType 035 public interface TeamPersistence extends BasePersistence<Team> { 036 /* 037 * NOTE FOR DEVELOPERS: 038 * 039 * Never modify or reference this interface directly. Always use {@link TeamUtil} to access the team persistence. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this interface. 040 */ 041 042 /** 043 * Returns all the teams where uuid = ?. 044 * 045 * @param uuid the uuid 046 * @return the matching teams 047 */ 048 public java.util.List<Team> findByUuid(java.lang.String uuid); 049 050 /** 051 * Returns a range of all the teams where uuid = ?. 052 * 053 * <p> 054 * 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 TeamModelImpl}. 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. 055 * </p> 056 * 057 * @param uuid the uuid 058 * @param start the lower bound of the range of teams 059 * @param end the upper bound of the range of teams (not inclusive) 060 * @return the range of matching teams 061 */ 062 public java.util.List<Team> findByUuid(java.lang.String uuid, int start, 063 int end); 064 065 /** 066 * Returns an ordered range of all the teams where uuid = ?. 067 * 068 * <p> 069 * 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 TeamModelImpl}. 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. 070 * </p> 071 * 072 * @param uuid the uuid 073 * @param start the lower bound of the range of teams 074 * @param end the upper bound of the range of teams (not inclusive) 075 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 076 * @return the ordered range of matching teams 077 */ 078 public java.util.List<Team> findByUuid(java.lang.String uuid, int start, 079 int end, 080 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator); 081 082 /** 083 * Returns an ordered range of all the teams where uuid = ?. 084 * 085 * <p> 086 * 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 TeamModelImpl}. 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. 087 * </p> 088 * 089 * @param uuid the uuid 090 * @param start the lower bound of the range of teams 091 * @param end the upper bound of the range of teams (not inclusive) 092 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 093 * @param retrieveFromCache whether to retrieve from the finder cache 094 * @return the ordered range of matching teams 095 */ 096 public java.util.List<Team> findByUuid(java.lang.String uuid, int start, 097 int end, 098 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator, 099 boolean retrieveFromCache); 100 101 /** 102 * Returns the first team in the ordered set where uuid = ?. 103 * 104 * @param uuid the uuid 105 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 106 * @return the first matching team 107 * @throws NoSuchTeamException if a matching team could not be found 108 */ 109 public Team findByUuid_First(java.lang.String uuid, 110 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator) 111 throws NoSuchTeamException; 112 113 /** 114 * Returns the first team in the ordered set where uuid = ?. 115 * 116 * @param uuid the uuid 117 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 118 * @return the first matching team, or <code>null</code> if a matching team could not be found 119 */ 120 public Team fetchByUuid_First(java.lang.String uuid, 121 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator); 122 123 /** 124 * Returns the last team in the ordered set where uuid = ?. 125 * 126 * @param uuid the uuid 127 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 128 * @return the last matching team 129 * @throws NoSuchTeamException if a matching team could not be found 130 */ 131 public Team findByUuid_Last(java.lang.String uuid, 132 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator) 133 throws NoSuchTeamException; 134 135 /** 136 * Returns the last team in the ordered set where uuid = ?. 137 * 138 * @param uuid the uuid 139 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 140 * @return the last matching team, or <code>null</code> if a matching team could not be found 141 */ 142 public Team fetchByUuid_Last(java.lang.String uuid, 143 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator); 144 145 /** 146 * Returns the teams before and after the current team in the ordered set where uuid = ?. 147 * 148 * @param teamId the primary key of the current team 149 * @param uuid the uuid 150 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 151 * @return the previous, current, and next team 152 * @throws NoSuchTeamException if a team with the primary key could not be found 153 */ 154 public Team[] findByUuid_PrevAndNext(long teamId, java.lang.String uuid, 155 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator) 156 throws NoSuchTeamException; 157 158 /** 159 * Removes all the teams where uuid = ? from the database. 160 * 161 * @param uuid the uuid 162 */ 163 public void removeByUuid(java.lang.String uuid); 164 165 /** 166 * Returns the number of teams where uuid = ?. 167 * 168 * @param uuid the uuid 169 * @return the number of matching teams 170 */ 171 public int countByUuid(java.lang.String uuid); 172 173 /** 174 * Returns the team where uuid = ? and groupId = ? or throws a {@link NoSuchTeamException} if it could not be found. 175 * 176 * @param uuid the uuid 177 * @param groupId the group ID 178 * @return the matching team 179 * @throws NoSuchTeamException if a matching team could not be found 180 */ 181 public Team findByUUID_G(java.lang.String uuid, long groupId) 182 throws NoSuchTeamException; 183 184 /** 185 * Returns the team where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 186 * 187 * @param uuid the uuid 188 * @param groupId the group ID 189 * @return the matching team, or <code>null</code> if a matching team could not be found 190 */ 191 public Team fetchByUUID_G(java.lang.String uuid, long groupId); 192 193 /** 194 * Returns the team where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 195 * 196 * @param uuid the uuid 197 * @param groupId the group ID 198 * @param retrieveFromCache whether to retrieve from the finder cache 199 * @return the matching team, or <code>null</code> if a matching team could not be found 200 */ 201 public Team fetchByUUID_G(java.lang.String uuid, long groupId, 202 boolean retrieveFromCache); 203 204 /** 205 * Removes the team where uuid = ? and groupId = ? from the database. 206 * 207 * @param uuid the uuid 208 * @param groupId the group ID 209 * @return the team that was removed 210 */ 211 public Team removeByUUID_G(java.lang.String uuid, long groupId) 212 throws NoSuchTeamException; 213 214 /** 215 * Returns the number of teams where uuid = ? and groupId = ?. 216 * 217 * @param uuid the uuid 218 * @param groupId the group ID 219 * @return the number of matching teams 220 */ 221 public int countByUUID_G(java.lang.String uuid, long groupId); 222 223 /** 224 * Returns all the teams where uuid = ? and companyId = ?. 225 * 226 * @param uuid the uuid 227 * @param companyId the company ID 228 * @return the matching teams 229 */ 230 public java.util.List<Team> findByUuid_C(java.lang.String uuid, 231 long companyId); 232 233 /** 234 * Returns a range of all the teams where uuid = ? and companyId = ?. 235 * 236 * <p> 237 * 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 TeamModelImpl}. 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. 238 * </p> 239 * 240 * @param uuid the uuid 241 * @param companyId the company ID 242 * @param start the lower bound of the range of teams 243 * @param end the upper bound of the range of teams (not inclusive) 244 * @return the range of matching teams 245 */ 246 public java.util.List<Team> findByUuid_C(java.lang.String uuid, 247 long companyId, int start, int end); 248 249 /** 250 * Returns an ordered range of all the teams where uuid = ? and companyId = ?. 251 * 252 * <p> 253 * 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 TeamModelImpl}. 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. 254 * </p> 255 * 256 * @param uuid the uuid 257 * @param companyId the company ID 258 * @param start the lower bound of the range of teams 259 * @param end the upper bound of the range of teams (not inclusive) 260 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 261 * @return the ordered range of matching teams 262 */ 263 public java.util.List<Team> findByUuid_C(java.lang.String uuid, 264 long companyId, int start, int end, 265 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator); 266 267 /** 268 * Returns an ordered range of all the teams where uuid = ? and companyId = ?. 269 * 270 * <p> 271 * 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 TeamModelImpl}. 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. 272 * </p> 273 * 274 * @param uuid the uuid 275 * @param companyId the company ID 276 * @param start the lower bound of the range of teams 277 * @param end the upper bound of the range of teams (not inclusive) 278 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 279 * @param retrieveFromCache whether to retrieve from the finder cache 280 * @return the ordered range of matching teams 281 */ 282 public java.util.List<Team> findByUuid_C(java.lang.String uuid, 283 long companyId, int start, int end, 284 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator, 285 boolean retrieveFromCache); 286 287 /** 288 * Returns the first team in the ordered set where uuid = ? and companyId = ?. 289 * 290 * @param uuid the uuid 291 * @param companyId the company ID 292 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 293 * @return the first matching team 294 * @throws NoSuchTeamException if a matching team could not be found 295 */ 296 public Team findByUuid_C_First(java.lang.String uuid, long companyId, 297 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator) 298 throws NoSuchTeamException; 299 300 /** 301 * Returns the first team in the ordered set where uuid = ? and companyId = ?. 302 * 303 * @param uuid the uuid 304 * @param companyId the company ID 305 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 306 * @return the first matching team, or <code>null</code> if a matching team could not be found 307 */ 308 public Team fetchByUuid_C_First(java.lang.String uuid, long companyId, 309 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator); 310 311 /** 312 * Returns the last team in the ordered set where uuid = ? and companyId = ?. 313 * 314 * @param uuid the uuid 315 * @param companyId the company ID 316 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 317 * @return the last matching team 318 * @throws NoSuchTeamException if a matching team could not be found 319 */ 320 public Team findByUuid_C_Last(java.lang.String uuid, long companyId, 321 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator) 322 throws NoSuchTeamException; 323 324 /** 325 * Returns the last team in the ordered set where uuid = ? and companyId = ?. 326 * 327 * @param uuid the uuid 328 * @param companyId the company ID 329 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 330 * @return the last matching team, or <code>null</code> if a matching team could not be found 331 */ 332 public Team fetchByUuid_C_Last(java.lang.String uuid, long companyId, 333 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator); 334 335 /** 336 * Returns the teams before and after the current team in the ordered set where uuid = ? and companyId = ?. 337 * 338 * @param teamId the primary key of the current team 339 * @param uuid the uuid 340 * @param companyId the company ID 341 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 342 * @return the previous, current, and next team 343 * @throws NoSuchTeamException if a team with the primary key could not be found 344 */ 345 public Team[] findByUuid_C_PrevAndNext(long teamId, java.lang.String uuid, 346 long companyId, 347 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator) 348 throws NoSuchTeamException; 349 350 /** 351 * Removes all the teams where uuid = ? and companyId = ? from the database. 352 * 353 * @param uuid the uuid 354 * @param companyId the company ID 355 */ 356 public void removeByUuid_C(java.lang.String uuid, long companyId); 357 358 /** 359 * Returns the number of teams where uuid = ? and companyId = ?. 360 * 361 * @param uuid the uuid 362 * @param companyId the company ID 363 * @return the number of matching teams 364 */ 365 public int countByUuid_C(java.lang.String uuid, long companyId); 366 367 /** 368 * Returns all the teams where groupId = ?. 369 * 370 * @param groupId the group ID 371 * @return the matching teams 372 */ 373 public java.util.List<Team> findByGroupId(long groupId); 374 375 /** 376 * Returns a range of all the teams where groupId = ?. 377 * 378 * <p> 379 * 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 TeamModelImpl}. 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. 380 * </p> 381 * 382 * @param groupId the group ID 383 * @param start the lower bound of the range of teams 384 * @param end the upper bound of the range of teams (not inclusive) 385 * @return the range of matching teams 386 */ 387 public java.util.List<Team> findByGroupId(long groupId, int start, int end); 388 389 /** 390 * Returns an ordered range of all the teams where groupId = ?. 391 * 392 * <p> 393 * 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 TeamModelImpl}. 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. 394 * </p> 395 * 396 * @param groupId the group ID 397 * @param start the lower bound of the range of teams 398 * @param end the upper bound of the range of teams (not inclusive) 399 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 400 * @return the ordered range of matching teams 401 */ 402 public java.util.List<Team> findByGroupId(long groupId, int start, int end, 403 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator); 404 405 /** 406 * Returns an ordered range of all the teams where groupId = ?. 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 TeamModelImpl}. 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 groupId the group ID 413 * @param start the lower bound of the range of teams 414 * @param end the upper bound of the range of teams (not inclusive) 415 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 416 * @param retrieveFromCache whether to retrieve from the finder cache 417 * @return the ordered range of matching teams 418 */ 419 public java.util.List<Team> findByGroupId(long groupId, int start, int end, 420 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator, 421 boolean retrieveFromCache); 422 423 /** 424 * Returns the first team in the ordered set where groupId = ?. 425 * 426 * @param groupId the group ID 427 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 428 * @return the first matching team 429 * @throws NoSuchTeamException if a matching team could not be found 430 */ 431 public Team findByGroupId_First(long groupId, 432 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator) 433 throws NoSuchTeamException; 434 435 /** 436 * Returns the first team in the ordered set where groupId = ?. 437 * 438 * @param groupId the group ID 439 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 440 * @return the first matching team, or <code>null</code> if a matching team could not be found 441 */ 442 public Team fetchByGroupId_First(long groupId, 443 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator); 444 445 /** 446 * Returns the last team in the ordered set where groupId = ?. 447 * 448 * @param groupId the group ID 449 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 450 * @return the last matching team 451 * @throws NoSuchTeamException if a matching team could not be found 452 */ 453 public Team findByGroupId_Last(long groupId, 454 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator) 455 throws NoSuchTeamException; 456 457 /** 458 * Returns the last team in the ordered set where groupId = ?. 459 * 460 * @param groupId the group ID 461 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 462 * @return the last matching team, or <code>null</code> if a matching team could not be found 463 */ 464 public Team fetchByGroupId_Last(long groupId, 465 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator); 466 467 /** 468 * Returns the teams before and after the current team in the ordered set where groupId = ?. 469 * 470 * @param teamId the primary key of the current team 471 * @param groupId the group ID 472 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 473 * @return the previous, current, and next team 474 * @throws NoSuchTeamException if a team with the primary key could not be found 475 */ 476 public Team[] findByGroupId_PrevAndNext(long teamId, long groupId, 477 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator) 478 throws NoSuchTeamException; 479 480 /** 481 * Returns all the teams that the user has permission to view where groupId = ?. 482 * 483 * @param groupId the group ID 484 * @return the matching teams that the user has permission to view 485 */ 486 public java.util.List<Team> filterFindByGroupId(long groupId); 487 488 /** 489 * Returns a range of all the teams that the user has permission to view where groupId = ?. 490 * 491 * <p> 492 * 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 TeamModelImpl}. 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. 493 * </p> 494 * 495 * @param groupId the group ID 496 * @param start the lower bound of the range of teams 497 * @param end the upper bound of the range of teams (not inclusive) 498 * @return the range of matching teams that the user has permission to view 499 */ 500 public java.util.List<Team> filterFindByGroupId(long groupId, int start, 501 int end); 502 503 /** 504 * Returns an ordered range of all the teams that the user has permissions to view where groupId = ?. 505 * 506 * <p> 507 * 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 TeamModelImpl}. 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. 508 * </p> 509 * 510 * @param groupId the group ID 511 * @param start the lower bound of the range of teams 512 * @param end the upper bound of the range of teams (not inclusive) 513 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 514 * @return the ordered range of matching teams that the user has permission to view 515 */ 516 public java.util.List<Team> filterFindByGroupId(long groupId, int start, 517 int end, 518 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator); 519 520 /** 521 * Returns the teams before and after the current team in the ordered set of teams that the user has permission to view where groupId = ?. 522 * 523 * @param teamId the primary key of the current team 524 * @param groupId the group ID 525 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 526 * @return the previous, current, and next team 527 * @throws NoSuchTeamException if a team with the primary key could not be found 528 */ 529 public Team[] filterFindByGroupId_PrevAndNext(long teamId, long groupId, 530 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator) 531 throws NoSuchTeamException; 532 533 /** 534 * Removes all the teams where groupId = ? from the database. 535 * 536 * @param groupId the group ID 537 */ 538 public void removeByGroupId(long groupId); 539 540 /** 541 * Returns the number of teams where groupId = ?. 542 * 543 * @param groupId the group ID 544 * @return the number of matching teams 545 */ 546 public int countByGroupId(long groupId); 547 548 /** 549 * Returns the number of teams that the user has permission to view where groupId = ?. 550 * 551 * @param groupId the group ID 552 * @return the number of matching teams that the user has permission to view 553 */ 554 public int filterCountByGroupId(long groupId); 555 556 /** 557 * Returns the team where groupId = ? and name = ? or throws a {@link NoSuchTeamException} if it could not be found. 558 * 559 * @param groupId the group ID 560 * @param name the name 561 * @return the matching team 562 * @throws NoSuchTeamException if a matching team could not be found 563 */ 564 public Team findByG_N(long groupId, java.lang.String name) 565 throws NoSuchTeamException; 566 567 /** 568 * Returns the team where groupId = ? and name = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 569 * 570 * @param groupId the group ID 571 * @param name the name 572 * @return the matching team, or <code>null</code> if a matching team could not be found 573 */ 574 public Team fetchByG_N(long groupId, java.lang.String name); 575 576 /** 577 * Returns the team where groupId = ? and name = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 578 * 579 * @param groupId the group ID 580 * @param name the name 581 * @param retrieveFromCache whether to retrieve from the finder cache 582 * @return the matching team, or <code>null</code> if a matching team could not be found 583 */ 584 public Team fetchByG_N(long groupId, java.lang.String name, 585 boolean retrieveFromCache); 586 587 /** 588 * Removes the team where groupId = ? and name = ? from the database. 589 * 590 * @param groupId the group ID 591 * @param name the name 592 * @return the team that was removed 593 */ 594 public Team removeByG_N(long groupId, java.lang.String name) 595 throws NoSuchTeamException; 596 597 /** 598 * Returns the number of teams where groupId = ? and name = ?. 599 * 600 * @param groupId the group ID 601 * @param name the name 602 * @return the number of matching teams 603 */ 604 public int countByG_N(long groupId, java.lang.String name); 605 606 /** 607 * Caches the team in the entity cache if it is enabled. 608 * 609 * @param team the team 610 */ 611 public void cacheResult(Team team); 612 613 /** 614 * Caches the teams in the entity cache if it is enabled. 615 * 616 * @param teams the teams 617 */ 618 public void cacheResult(java.util.List<Team> teams); 619 620 /** 621 * Creates a new team with the primary key. Does not add the team to the database. 622 * 623 * @param teamId the primary key for the new team 624 * @return the new team 625 */ 626 public Team create(long teamId); 627 628 /** 629 * Removes the team with the primary key from the database. Also notifies the appropriate model listeners. 630 * 631 * @param teamId the primary key of the team 632 * @return the team that was removed 633 * @throws NoSuchTeamException if a team with the primary key could not be found 634 */ 635 public Team remove(long teamId) throws NoSuchTeamException; 636 637 public Team updateImpl(Team team); 638 639 /** 640 * Returns the team with the primary key or throws a {@link NoSuchTeamException} if it could not be found. 641 * 642 * @param teamId the primary key of the team 643 * @return the team 644 * @throws NoSuchTeamException if a team with the primary key could not be found 645 */ 646 public Team findByPrimaryKey(long teamId) throws NoSuchTeamException; 647 648 /** 649 * Returns the team with the primary key or returns <code>null</code> if it could not be found. 650 * 651 * @param teamId the primary key of the team 652 * @return the team, or <code>null</code> if a team with the primary key could not be found 653 */ 654 public Team fetchByPrimaryKey(long teamId); 655 656 @Override 657 public java.util.Map<java.io.Serializable, Team> fetchByPrimaryKeys( 658 java.util.Set<java.io.Serializable> primaryKeys); 659 660 /** 661 * Returns all the teams. 662 * 663 * @return the teams 664 */ 665 public java.util.List<Team> findAll(); 666 667 /** 668 * Returns a range of all the teams. 669 * 670 * <p> 671 * 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 TeamModelImpl}. 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. 672 * </p> 673 * 674 * @param start the lower bound of the range of teams 675 * @param end the upper bound of the range of teams (not inclusive) 676 * @return the range of teams 677 */ 678 public java.util.List<Team> findAll(int start, int end); 679 680 /** 681 * Returns an ordered range of all the teams. 682 * 683 * <p> 684 * 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 TeamModelImpl}. 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. 685 * </p> 686 * 687 * @param start the lower bound of the range of teams 688 * @param end the upper bound of the range of teams (not inclusive) 689 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 690 * @return the ordered range of teams 691 */ 692 public java.util.List<Team> findAll(int start, int end, 693 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator); 694 695 /** 696 * Returns an ordered range of all the teams. 697 * 698 * <p> 699 * 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 TeamModelImpl}. 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. 700 * </p> 701 * 702 * @param start the lower bound of the range of teams 703 * @param end the upper bound of the range of teams (not inclusive) 704 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 705 * @param retrieveFromCache whether to retrieve from the finder cache 706 * @return the ordered range of teams 707 */ 708 public java.util.List<Team> findAll(int start, int end, 709 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator, 710 boolean retrieveFromCache); 711 712 /** 713 * Removes all the teams from the database. 714 */ 715 public void removeAll(); 716 717 /** 718 * Returns the number of teams. 719 * 720 * @return the number of teams 721 */ 722 public int countAll(); 723 724 /** 725 * Returns the primaryKeys of users associated with the team. 726 * 727 * @param pk the primary key of the team 728 * @return long[] of the primaryKeys of users associated with the team 729 */ 730 public long[] getUserPrimaryKeys(long pk); 731 732 /** 733 * Returns all the users associated with the team. 734 * 735 * @param pk the primary key of the team 736 * @return the users associated with the team 737 */ 738 public java.util.List<com.liferay.portal.model.User> getUsers(long pk); 739 740 /** 741 * Returns a range of all the users associated with the team. 742 * 743 * <p> 744 * 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 TeamModelImpl}. 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. 745 * </p> 746 * 747 * @param pk the primary key of the team 748 * @param start the lower bound of the range of teams 749 * @param end the upper bound of the range of teams (not inclusive) 750 * @return the range of users associated with the team 751 */ 752 public java.util.List<com.liferay.portal.model.User> getUsers(long pk, 753 int start, int end); 754 755 /** 756 * Returns an ordered range of all the users associated with the team. 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 TeamModelImpl}. 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 pk the primary key of the team 763 * @param start the lower bound of the range of teams 764 * @param end the upper bound of the range of teams (not inclusive) 765 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 766 * @return the ordered range of users associated with the team 767 */ 768 public java.util.List<com.liferay.portal.model.User> getUsers(long pk, 769 int start, int end, 770 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.User> orderByComparator); 771 772 /** 773 * Returns the number of users associated with the team. 774 * 775 * @param pk the primary key of the team 776 * @return the number of users associated with the team 777 */ 778 public int getUsersSize(long pk); 779 780 /** 781 * Returns <code>true</code> if the user is associated with the team. 782 * 783 * @param pk the primary key of the team 784 * @param userPK the primary key of the user 785 * @return <code>true</code> if the user is associated with the team; <code>false</code> otherwise 786 */ 787 public boolean containsUser(long pk, long userPK); 788 789 /** 790 * Returns <code>true</code> if the team has any users associated with it. 791 * 792 * @param pk the primary key of the team to check for associations with users 793 * @return <code>true</code> if the team has any users associated with it; <code>false</code> otherwise 794 */ 795 public boolean containsUsers(long pk); 796 797 /** 798 * Adds an association between the team and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache. 799 * 800 * @param pk the primary key of the team 801 * @param userPK the primary key of the user 802 */ 803 public void addUser(long pk, long userPK); 804 805 /** 806 * Adds an association between the team and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache. 807 * 808 * @param pk the primary key of the team 809 * @param user the user 810 */ 811 public void addUser(long pk, com.liferay.portal.model.User user); 812 813 /** 814 * Adds an association between the team and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache. 815 * 816 * @param pk the primary key of the team 817 * @param userPKs the primary keys of the users 818 */ 819 public void addUsers(long pk, long[] userPKs); 820 821 /** 822 * Adds an association between the team and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache. 823 * 824 * @param pk the primary key of the team 825 * @param users the users 826 */ 827 public void addUsers(long pk, 828 java.util.List<com.liferay.portal.model.User> users); 829 830 /** 831 * Clears all associations between the team and its users. Also notifies the appropriate model listeners and clears the mapping table finder cache. 832 * 833 * @param pk the primary key of the team to clear the associated users from 834 */ 835 public void clearUsers(long pk); 836 837 /** 838 * Removes the association between the team and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache. 839 * 840 * @param pk the primary key of the team 841 * @param userPK the primary key of the user 842 */ 843 public void removeUser(long pk, long userPK); 844 845 /** 846 * Removes the association between the team and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache. 847 * 848 * @param pk the primary key of the team 849 * @param user the user 850 */ 851 public void removeUser(long pk, com.liferay.portal.model.User user); 852 853 /** 854 * Removes the association between the team and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache. 855 * 856 * @param pk the primary key of the team 857 * @param userPKs the primary keys of the users 858 */ 859 public void removeUsers(long pk, long[] userPKs); 860 861 /** 862 * Removes the association between the team and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache. 863 * 864 * @param pk the primary key of the team 865 * @param users the users 866 */ 867 public void removeUsers(long pk, 868 java.util.List<com.liferay.portal.model.User> users); 869 870 /** 871 * Sets the users associated with the team, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 872 * 873 * @param pk the primary key of the team 874 * @param userPKs the primary keys of the users to be associated with the team 875 */ 876 public void setUsers(long pk, long[] userPKs); 877 878 /** 879 * Sets the users associated with the team, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 880 * 881 * @param pk the primary key of the team 882 * @param users the users to be associated with the team 883 */ 884 public void setUsers(long pk, 885 java.util.List<com.liferay.portal.model.User> users); 886 887 /** 888 * Returns the primaryKeys of user groups associated with the team. 889 * 890 * @param pk the primary key of the team 891 * @return long[] of the primaryKeys of user groups associated with the team 892 */ 893 public long[] getUserGroupPrimaryKeys(long pk); 894 895 /** 896 * Returns all the user groups associated with the team. 897 * 898 * @param pk the primary key of the team 899 * @return the user groups associated with the team 900 */ 901 public java.util.List<com.liferay.portal.model.UserGroup> getUserGroups( 902 long pk); 903 904 /** 905 * Returns a range of all the user groups associated with the team. 906 * 907 * <p> 908 * 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 TeamModelImpl}. 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. 909 * </p> 910 * 911 * @param pk the primary key of the team 912 * @param start the lower bound of the range of teams 913 * @param end the upper bound of the range of teams (not inclusive) 914 * @return the range of user groups associated with the team 915 */ 916 public java.util.List<com.liferay.portal.model.UserGroup> getUserGroups( 917 long pk, int start, int end); 918 919 /** 920 * Returns an ordered range of all the user groups associated with the team. 921 * 922 * <p> 923 * 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 TeamModelImpl}. 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. 924 * </p> 925 * 926 * @param pk the primary key of the team 927 * @param start the lower bound of the range of teams 928 * @param end the upper bound of the range of teams (not inclusive) 929 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 930 * @return the ordered range of user groups associated with the team 931 */ 932 public java.util.List<com.liferay.portal.model.UserGroup> getUserGroups( 933 long pk, int start, int end, 934 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.model.UserGroup> orderByComparator); 935 936 /** 937 * Returns the number of user groups associated with the team. 938 * 939 * @param pk the primary key of the team 940 * @return the number of user groups associated with the team 941 */ 942 public int getUserGroupsSize(long pk); 943 944 /** 945 * Returns <code>true</code> if the user group is associated with the team. 946 * 947 * @param pk the primary key of the team 948 * @param userGroupPK the primary key of the user group 949 * @return <code>true</code> if the user group is associated with the team; <code>false</code> otherwise 950 */ 951 public boolean containsUserGroup(long pk, long userGroupPK); 952 953 /** 954 * Returns <code>true</code> if the team has any user groups associated with it. 955 * 956 * @param pk the primary key of the team to check for associations with user groups 957 * @return <code>true</code> if the team has any user groups associated with it; <code>false</code> otherwise 958 */ 959 public boolean containsUserGroups(long pk); 960 961 /** 962 * Adds an association between the team and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache. 963 * 964 * @param pk the primary key of the team 965 * @param userGroupPK the primary key of the user group 966 */ 967 public void addUserGroup(long pk, long userGroupPK); 968 969 /** 970 * Adds an association between the team and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache. 971 * 972 * @param pk the primary key of the team 973 * @param userGroup the user group 974 */ 975 public void addUserGroup(long pk, 976 com.liferay.portal.model.UserGroup userGroup); 977 978 /** 979 * Adds an association between the team and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 980 * 981 * @param pk the primary key of the team 982 * @param userGroupPKs the primary keys of the user groups 983 */ 984 public void addUserGroups(long pk, long[] userGroupPKs); 985 986 /** 987 * Adds an association between the team and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 988 * 989 * @param pk the primary key of the team 990 * @param userGroups the user groups 991 */ 992 public void addUserGroups(long pk, 993 java.util.List<com.liferay.portal.model.UserGroup> userGroups); 994 995 /** 996 * Clears all associations between the team and its user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 997 * 998 * @param pk the primary key of the team to clear the associated user groups from 999 */ 1000 public void clearUserGroups(long pk); 1001 1002 /** 1003 * Removes the association between the team and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1004 * 1005 * @param pk the primary key of the team 1006 * @param userGroupPK the primary key of the user group 1007 */ 1008 public void removeUserGroup(long pk, long userGroupPK); 1009 1010 /** 1011 * Removes the association between the team and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1012 * 1013 * @param pk the primary key of the team 1014 * @param userGroup the user group 1015 */ 1016 public void removeUserGroup(long pk, 1017 com.liferay.portal.model.UserGroup userGroup); 1018 1019 /** 1020 * Removes the association between the team and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1021 * 1022 * @param pk the primary key of the team 1023 * @param userGroupPKs the primary keys of the user groups 1024 */ 1025 public void removeUserGroups(long pk, long[] userGroupPKs); 1026 1027 /** 1028 * Removes the association between the team and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1029 * 1030 * @param pk the primary key of the team 1031 * @param userGroups the user groups 1032 */ 1033 public void removeUserGroups(long pk, 1034 java.util.List<com.liferay.portal.model.UserGroup> userGroups); 1035 1036 /** 1037 * Sets the user groups associated with the team, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1038 * 1039 * @param pk the primary key of the team 1040 * @param userGroupPKs the primary keys of the user groups to be associated with the team 1041 */ 1042 public void setUserGroups(long pk, long[] userGroupPKs); 1043 1044 /** 1045 * Sets the user groups associated with the team, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1046 * 1047 * @param pk the primary key of the team 1048 * @param userGroups the user groups to be associated with the team 1049 */ 1050 public void setUserGroups(long pk, 1051 java.util.List<com.liferay.portal.model.UserGroup> userGroups); 1052 1053 @Override 1054 public java.util.Set<java.lang.String> getBadColumnNames(); 1055 }