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.kernel.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.kernel.exception.NoSuchTeamException; 020 import com.liferay.portal.kernel.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.kernel.model.User> getUsers( 739 long pk); 740 741 /** 742 * Returns a range of all the users associated with the team. 743 * 744 * <p> 745 * 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. 746 * </p> 747 * 748 * @param pk the primary key of the team 749 * @param start the lower bound of the range of teams 750 * @param end the upper bound of the range of teams (not inclusive) 751 * @return the range of users associated with the team 752 */ 753 public java.util.List<com.liferay.portal.kernel.model.User> getUsers( 754 long pk, int start, int end); 755 756 /** 757 * Returns an ordered range of all the users associated with the team. 758 * 759 * <p> 760 * 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. 761 * </p> 762 * 763 * @param pk the primary key of the team 764 * @param start the lower bound of the range of teams 765 * @param end the upper bound of the range of teams (not inclusive) 766 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 767 * @return the ordered range of users associated with the team 768 */ 769 public java.util.List<com.liferay.portal.kernel.model.User> getUsers( 770 long pk, int start, int end, 771 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.model.User> orderByComparator); 772 773 /** 774 * Returns the number of users associated with the team. 775 * 776 * @param pk the primary key of the team 777 * @return the number of users associated with the team 778 */ 779 public int getUsersSize(long pk); 780 781 /** 782 * Returns <code>true</code> if the user is associated with the team. 783 * 784 * @param pk the primary key of the team 785 * @param userPK the primary key of the user 786 * @return <code>true</code> if the user is associated with the team; <code>false</code> otherwise 787 */ 788 public boolean containsUser(long pk, long userPK); 789 790 /** 791 * Returns <code>true</code> if the team has any users associated with it. 792 * 793 * @param pk the primary key of the team to check for associations with users 794 * @return <code>true</code> if the team has any users associated with it; <code>false</code> otherwise 795 */ 796 public boolean containsUsers(long pk); 797 798 /** 799 * Adds an association between the team and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache. 800 * 801 * @param pk the primary key of the team 802 * @param userPK the primary key of the user 803 */ 804 public void addUser(long pk, long userPK); 805 806 /** 807 * Adds an association between the team and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache. 808 * 809 * @param pk the primary key of the team 810 * @param user the user 811 */ 812 public void addUser(long pk, com.liferay.portal.kernel.model.User user); 813 814 /** 815 * Adds an association between the team and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache. 816 * 817 * @param pk the primary key of the team 818 * @param userPKs the primary keys of the users 819 */ 820 public void addUsers(long pk, long[] userPKs); 821 822 /** 823 * Adds an association between the team and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache. 824 * 825 * @param pk the primary key of the team 826 * @param users the users 827 */ 828 public void addUsers(long pk, 829 java.util.List<com.liferay.portal.kernel.model.User> users); 830 831 /** 832 * Clears all associations between the team and its users. Also notifies the appropriate model listeners and clears the mapping table finder cache. 833 * 834 * @param pk the primary key of the team to clear the associated users from 835 */ 836 public void clearUsers(long pk); 837 838 /** 839 * Removes the association between the team and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache. 840 * 841 * @param pk the primary key of the team 842 * @param userPK the primary key of the user 843 */ 844 public void removeUser(long pk, long userPK); 845 846 /** 847 * Removes the association between the team and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache. 848 * 849 * @param pk the primary key of the team 850 * @param user the user 851 */ 852 public void removeUser(long pk, com.liferay.portal.kernel.model.User user); 853 854 /** 855 * Removes the association between the team and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache. 856 * 857 * @param pk the primary key of the team 858 * @param userPKs the primary keys of the users 859 */ 860 public void removeUsers(long pk, long[] userPKs); 861 862 /** 863 * Removes the association between the team and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache. 864 * 865 * @param pk the primary key of the team 866 * @param users the users 867 */ 868 public void removeUsers(long pk, 869 java.util.List<com.liferay.portal.kernel.model.User> users); 870 871 /** 872 * 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. 873 * 874 * @param pk the primary key of the team 875 * @param userPKs the primary keys of the users to be associated with the team 876 */ 877 public void setUsers(long pk, long[] userPKs); 878 879 /** 880 * 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. 881 * 882 * @param pk the primary key of the team 883 * @param users the users to be associated with the team 884 */ 885 public void setUsers(long pk, 886 java.util.List<com.liferay.portal.kernel.model.User> users); 887 888 /** 889 * Returns the primaryKeys of user groups associated with the team. 890 * 891 * @param pk the primary key of the team 892 * @return long[] of the primaryKeys of user groups associated with the team 893 */ 894 public long[] getUserGroupPrimaryKeys(long pk); 895 896 /** 897 * Returns all the user groups associated with the team. 898 * 899 * @param pk the primary key of the team 900 * @return the user groups associated with the team 901 */ 902 public java.util.List<com.liferay.portal.kernel.model.UserGroup> getUserGroups( 903 long pk); 904 905 /** 906 * Returns a range of all the user groups associated with the team. 907 * 908 * <p> 909 * 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. 910 * </p> 911 * 912 * @param pk the primary key of the team 913 * @param start the lower bound of the range of teams 914 * @param end the upper bound of the range of teams (not inclusive) 915 * @return the range of user groups associated with the team 916 */ 917 public java.util.List<com.liferay.portal.kernel.model.UserGroup> getUserGroups( 918 long pk, int start, int end); 919 920 /** 921 * Returns an ordered range of all the user groups associated with the team. 922 * 923 * <p> 924 * 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. 925 * </p> 926 * 927 * @param pk the primary key of the team 928 * @param start the lower bound of the range of teams 929 * @param end the upper bound of the range of teams (not inclusive) 930 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 931 * @return the ordered range of user groups associated with the team 932 */ 933 public java.util.List<com.liferay.portal.kernel.model.UserGroup> getUserGroups( 934 long pk, int start, int end, 935 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.kernel.model.UserGroup> orderByComparator); 936 937 /** 938 * Returns the number of user groups associated with the team. 939 * 940 * @param pk the primary key of the team 941 * @return the number of user groups associated with the team 942 */ 943 public int getUserGroupsSize(long pk); 944 945 /** 946 * Returns <code>true</code> if the user group is associated with the team. 947 * 948 * @param pk the primary key of the team 949 * @param userGroupPK the primary key of the user group 950 * @return <code>true</code> if the user group is associated with the team; <code>false</code> otherwise 951 */ 952 public boolean containsUserGroup(long pk, long userGroupPK); 953 954 /** 955 * Returns <code>true</code> if the team has any user groups associated with it. 956 * 957 * @param pk the primary key of the team to check for associations with user groups 958 * @return <code>true</code> if the team has any user groups associated with it; <code>false</code> otherwise 959 */ 960 public boolean containsUserGroups(long pk); 961 962 /** 963 * Adds an association between the team and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache. 964 * 965 * @param pk the primary key of the team 966 * @param userGroupPK the primary key of the user group 967 */ 968 public void addUserGroup(long pk, long userGroupPK); 969 970 /** 971 * Adds an association between the team and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache. 972 * 973 * @param pk the primary key of the team 974 * @param userGroup the user group 975 */ 976 public void addUserGroup(long pk, 977 com.liferay.portal.kernel.model.UserGroup userGroup); 978 979 /** 980 * Adds an association between the team and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 981 * 982 * @param pk the primary key of the team 983 * @param userGroupPKs the primary keys of the user groups 984 */ 985 public void addUserGroups(long pk, long[] userGroupPKs); 986 987 /** 988 * Adds an association between the team and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 989 * 990 * @param pk the primary key of the team 991 * @param userGroups the user groups 992 */ 993 public void addUserGroups(long pk, 994 java.util.List<com.liferay.portal.kernel.model.UserGroup> userGroups); 995 996 /** 997 * Clears all associations between the team and its user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 998 * 999 * @param pk the primary key of the team to clear the associated user groups from 1000 */ 1001 public void clearUserGroups(long pk); 1002 1003 /** 1004 * Removes the association between the team and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1005 * 1006 * @param pk the primary key of the team 1007 * @param userGroupPK the primary key of the user group 1008 */ 1009 public void removeUserGroup(long pk, long userGroupPK); 1010 1011 /** 1012 * Removes the association between the team and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1013 * 1014 * @param pk the primary key of the team 1015 * @param userGroup the user group 1016 */ 1017 public void removeUserGroup(long pk, 1018 com.liferay.portal.kernel.model.UserGroup userGroup); 1019 1020 /** 1021 * Removes the association between the team and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1022 * 1023 * @param pk the primary key of the team 1024 * @param userGroupPKs the primary keys of the user groups 1025 */ 1026 public void removeUserGroups(long pk, long[] userGroupPKs); 1027 1028 /** 1029 * Removes the association between the team and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1030 * 1031 * @param pk the primary key of the team 1032 * @param userGroups the user groups 1033 */ 1034 public void removeUserGroups(long pk, 1035 java.util.List<com.liferay.portal.kernel.model.UserGroup> userGroups); 1036 1037 /** 1038 * 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. 1039 * 1040 * @param pk the primary key of the team 1041 * @param userGroupPKs the primary keys of the user groups to be associated with the team 1042 */ 1043 public void setUserGroups(long pk, long[] userGroupPKs); 1044 1045 /** 1046 * 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. 1047 * 1048 * @param pk the primary key of the team 1049 * @param userGroups the user groups to be associated with the team 1050 */ 1051 public void setUserGroups(long pk, 1052 java.util.List<com.liferay.portal.kernel.model.UserGroup> userGroups); 1053 1054 @Override 1055 public java.util.Set<java.lang.String> getBadColumnNames(); 1056 }