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.model.Team; 020 021 /** 022 * The persistence interface for the team service. 023 * 024 * <p> 025 * Caching information and settings can be found in <code>portal.properties</code> 026 * </p> 027 * 028 * @author Brian Wing Shun Chan 029 * @see com.liferay.portal.service.persistence.impl.TeamPersistenceImpl 030 * @see TeamUtil 031 * @generated 032 */ 033 @ProviderType 034 public interface TeamPersistence extends BasePersistence<Team> { 035 /* 036 * NOTE FOR DEVELOPERS: 037 * 038 * 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. 039 */ 040 041 /** 042 * Returns all the teams where uuid = ?. 043 * 044 * @param uuid the uuid 045 * @return the matching teams 046 */ 047 public java.util.List<Team> findByUuid(java.lang.String uuid); 048 049 /** 050 * Returns a range of all the teams where uuid = ?. 051 * 052 * <p> 053 * 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. 054 * </p> 055 * 056 * @param uuid the uuid 057 * @param start the lower bound of the range of teams 058 * @param end the upper bound of the range of teams (not inclusive) 059 * @return the range of matching teams 060 */ 061 public java.util.List<Team> findByUuid(java.lang.String uuid, int start, 062 int end); 063 064 /** 065 * Returns an ordered range of all the teams where uuid = ?. 066 * 067 * <p> 068 * 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. 069 * </p> 070 * 071 * @param uuid the uuid 072 * @param start the lower bound of the range of teams 073 * @param end the upper bound of the range of teams (not inclusive) 074 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 075 * @return the ordered range of matching teams 076 */ 077 public java.util.List<Team> findByUuid(java.lang.String uuid, int start, 078 int end, 079 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator); 080 081 /** 082 * Returns an ordered range of all the teams where uuid = ?. 083 * 084 * <p> 085 * 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. 086 * </p> 087 * 088 * @param uuid the uuid 089 * @param start the lower bound of the range of teams 090 * @param end the upper bound of the range of teams (not inclusive) 091 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 092 * @param retrieveFromCache whether to retrieve from the finder cache 093 * @return the ordered range of matching teams 094 */ 095 public java.util.List<Team> findByUuid(java.lang.String uuid, int start, 096 int end, 097 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator, 098 boolean retrieveFromCache); 099 100 /** 101 * Returns the first team in the ordered set where uuid = ?. 102 * 103 * @param uuid the uuid 104 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 105 * @return the first matching team 106 * @throws NoSuchTeamException if a matching team could not be found 107 */ 108 public Team findByUuid_First(java.lang.String uuid, 109 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator) 110 throws com.liferay.portal.exception.NoSuchTeamException; 111 112 /** 113 * Returns the first team in the ordered set where uuid = ?. 114 * 115 * @param uuid the uuid 116 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 117 * @return the first matching team, or <code>null</code> if a matching team could not be found 118 */ 119 public Team fetchByUuid_First(java.lang.String uuid, 120 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator); 121 122 /** 123 * Returns the last team in the ordered set where uuid = ?. 124 * 125 * @param uuid the uuid 126 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 127 * @return the last matching team 128 * @throws NoSuchTeamException if a matching team could not be found 129 */ 130 public Team findByUuid_Last(java.lang.String uuid, 131 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator) 132 throws com.liferay.portal.exception.NoSuchTeamException; 133 134 /** 135 * Returns the last team in the ordered set where uuid = ?. 136 * 137 * @param uuid the uuid 138 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 139 * @return the last matching team, or <code>null</code> if a matching team could not be found 140 */ 141 public Team fetchByUuid_Last(java.lang.String uuid, 142 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator); 143 144 /** 145 * Returns the teams before and after the current team in the ordered set where uuid = ?. 146 * 147 * @param teamId the primary key of the current team 148 * @param uuid the uuid 149 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 150 * @return the previous, current, and next team 151 * @throws NoSuchTeamException if a team with the primary key could not be found 152 */ 153 public Team[] findByUuid_PrevAndNext(long teamId, java.lang.String uuid, 154 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator) 155 throws com.liferay.portal.exception.NoSuchTeamException; 156 157 /** 158 * Removes all the teams where uuid = ? from the database. 159 * 160 * @param uuid the uuid 161 */ 162 public void removeByUuid(java.lang.String uuid); 163 164 /** 165 * Returns the number of teams where uuid = ?. 166 * 167 * @param uuid the uuid 168 * @return the number of matching teams 169 */ 170 public int countByUuid(java.lang.String uuid); 171 172 /** 173 * Returns the team where uuid = ? and groupId = ? or throws a {@link NoSuchTeamException} if it could not be found. 174 * 175 * @param uuid the uuid 176 * @param groupId the group ID 177 * @return the matching team 178 * @throws NoSuchTeamException if a matching team could not be found 179 */ 180 public Team findByUUID_G(java.lang.String uuid, long groupId) 181 throws com.liferay.portal.exception.NoSuchTeamException; 182 183 /** 184 * Returns the team where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 185 * 186 * @param uuid the uuid 187 * @param groupId the group ID 188 * @return the matching team, or <code>null</code> if a matching team could not be found 189 */ 190 public Team fetchByUUID_G(java.lang.String uuid, long groupId); 191 192 /** 193 * Returns the team where uuid = ? and groupId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 194 * 195 * @param uuid the uuid 196 * @param groupId the group ID 197 * @param retrieveFromCache whether to retrieve from the finder cache 198 * @return the matching team, or <code>null</code> if a matching team could not be found 199 */ 200 public Team fetchByUUID_G(java.lang.String uuid, long groupId, 201 boolean retrieveFromCache); 202 203 /** 204 * Removes the team where uuid = ? and groupId = ? from the database. 205 * 206 * @param uuid the uuid 207 * @param groupId the group ID 208 * @return the team that was removed 209 */ 210 public Team removeByUUID_G(java.lang.String uuid, long groupId) 211 throws com.liferay.portal.exception.NoSuchTeamException; 212 213 /** 214 * Returns the number of teams where uuid = ? and groupId = ?. 215 * 216 * @param uuid the uuid 217 * @param groupId the group ID 218 * @return the number of matching teams 219 */ 220 public int countByUUID_G(java.lang.String uuid, long groupId); 221 222 /** 223 * Returns all the teams where uuid = ? and companyId = ?. 224 * 225 * @param uuid the uuid 226 * @param companyId the company ID 227 * @return the matching teams 228 */ 229 public java.util.List<Team> findByUuid_C(java.lang.String uuid, 230 long companyId); 231 232 /** 233 * Returns a range of all the teams where uuid = ? and companyId = ?. 234 * 235 * <p> 236 * 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. 237 * </p> 238 * 239 * @param uuid the uuid 240 * @param companyId the company ID 241 * @param start the lower bound of the range of teams 242 * @param end the upper bound of the range of teams (not inclusive) 243 * @return the range of matching teams 244 */ 245 public java.util.List<Team> findByUuid_C(java.lang.String uuid, 246 long companyId, int start, int end); 247 248 /** 249 * Returns an ordered range of all the teams where uuid = ? and companyId = ?. 250 * 251 * <p> 252 * 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. 253 * </p> 254 * 255 * @param uuid the uuid 256 * @param companyId the company ID 257 * @param start the lower bound of the range of teams 258 * @param end the upper bound of the range of teams (not inclusive) 259 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 260 * @return the ordered range of matching teams 261 */ 262 public java.util.List<Team> findByUuid_C(java.lang.String uuid, 263 long companyId, int start, int end, 264 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator); 265 266 /** 267 * Returns an ordered range of all the teams where uuid = ? and companyId = ?. 268 * 269 * <p> 270 * 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. 271 * </p> 272 * 273 * @param uuid the uuid 274 * @param companyId the company ID 275 * @param start the lower bound of the range of teams 276 * @param end the upper bound of the range of teams (not inclusive) 277 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 278 * @param retrieveFromCache whether to retrieve from the finder cache 279 * @return the ordered range of matching teams 280 */ 281 public java.util.List<Team> findByUuid_C(java.lang.String uuid, 282 long companyId, int start, int end, 283 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator, 284 boolean retrieveFromCache); 285 286 /** 287 * Returns the first team in the ordered set where uuid = ? and companyId = ?. 288 * 289 * @param uuid the uuid 290 * @param companyId the company ID 291 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 292 * @return the first matching team 293 * @throws NoSuchTeamException if a matching team could not be found 294 */ 295 public Team findByUuid_C_First(java.lang.String uuid, long companyId, 296 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator) 297 throws com.liferay.portal.exception.NoSuchTeamException; 298 299 /** 300 * Returns the first team in the ordered set where uuid = ? and companyId = ?. 301 * 302 * @param uuid the uuid 303 * @param companyId the company ID 304 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 305 * @return the first matching team, or <code>null</code> if a matching team could not be found 306 */ 307 public Team fetchByUuid_C_First(java.lang.String uuid, long companyId, 308 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator); 309 310 /** 311 * Returns the last team in the ordered set where uuid = ? and companyId = ?. 312 * 313 * @param uuid the uuid 314 * @param companyId the company ID 315 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 316 * @return the last matching team 317 * @throws NoSuchTeamException if a matching team could not be found 318 */ 319 public Team findByUuid_C_Last(java.lang.String uuid, long companyId, 320 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator) 321 throws com.liferay.portal.exception.NoSuchTeamException; 322 323 /** 324 * Returns the last team in the ordered set where uuid = ? and companyId = ?. 325 * 326 * @param uuid the uuid 327 * @param companyId the company ID 328 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 329 * @return the last matching team, or <code>null</code> if a matching team could not be found 330 */ 331 public Team fetchByUuid_C_Last(java.lang.String uuid, long companyId, 332 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator); 333 334 /** 335 * Returns the teams before and after the current team in the ordered set where uuid = ? and companyId = ?. 336 * 337 * @param teamId the primary key of the current team 338 * @param uuid the uuid 339 * @param companyId the company ID 340 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 341 * @return the previous, current, and next team 342 * @throws NoSuchTeamException if a team with the primary key could not be found 343 */ 344 public Team[] findByUuid_C_PrevAndNext(long teamId, java.lang.String uuid, 345 long companyId, 346 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator) 347 throws com.liferay.portal.exception.NoSuchTeamException; 348 349 /** 350 * Removes all the teams where uuid = ? and companyId = ? from the database. 351 * 352 * @param uuid the uuid 353 * @param companyId the company ID 354 */ 355 public void removeByUuid_C(java.lang.String uuid, long companyId); 356 357 /** 358 * Returns the number of teams where uuid = ? and companyId = ?. 359 * 360 * @param uuid the uuid 361 * @param companyId the company ID 362 * @return the number of matching teams 363 */ 364 public int countByUuid_C(java.lang.String uuid, long companyId); 365 366 /** 367 * Returns all the teams where groupId = ?. 368 * 369 * @param groupId the group ID 370 * @return the matching teams 371 */ 372 public java.util.List<Team> findByGroupId(long groupId); 373 374 /** 375 * Returns a range of all the teams where groupId = ?. 376 * 377 * <p> 378 * 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. 379 * </p> 380 * 381 * @param groupId the group ID 382 * @param start the lower bound of the range of teams 383 * @param end the upper bound of the range of teams (not inclusive) 384 * @return the range of matching teams 385 */ 386 public java.util.List<Team> findByGroupId(long groupId, int start, int end); 387 388 /** 389 * Returns an ordered range of all the teams where groupId = ?. 390 * 391 * <p> 392 * 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. 393 * </p> 394 * 395 * @param groupId the group ID 396 * @param start the lower bound of the range of teams 397 * @param end the upper bound of the range of teams (not inclusive) 398 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 399 * @return the ordered range of matching teams 400 */ 401 public java.util.List<Team> findByGroupId(long groupId, int start, int end, 402 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator); 403 404 /** 405 * Returns an ordered range of all the teams where groupId = ?. 406 * 407 * <p> 408 * 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. 409 * </p> 410 * 411 * @param groupId the group ID 412 * @param start the lower bound of the range of teams 413 * @param end the upper bound of the range of teams (not inclusive) 414 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 415 * @param retrieveFromCache whether to retrieve from the finder cache 416 * @return the ordered range of matching teams 417 */ 418 public java.util.List<Team> findByGroupId(long groupId, int start, int end, 419 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator, 420 boolean retrieveFromCache); 421 422 /** 423 * Returns the first team in the ordered set where groupId = ?. 424 * 425 * @param groupId the group ID 426 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 427 * @return the first matching team 428 * @throws NoSuchTeamException if a matching team could not be found 429 */ 430 public Team findByGroupId_First(long groupId, 431 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator) 432 throws com.liferay.portal.exception.NoSuchTeamException; 433 434 /** 435 * Returns the first team in the ordered set where groupId = ?. 436 * 437 * @param groupId the group ID 438 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 439 * @return the first matching team, or <code>null</code> if a matching team could not be found 440 */ 441 public Team fetchByGroupId_First(long groupId, 442 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator); 443 444 /** 445 * Returns the last team in the ordered set where groupId = ?. 446 * 447 * @param groupId the group ID 448 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 449 * @return the last matching team 450 * @throws NoSuchTeamException if a matching team could not be found 451 */ 452 public Team findByGroupId_Last(long groupId, 453 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator) 454 throws com.liferay.portal.exception.NoSuchTeamException; 455 456 /** 457 * Returns the last team in the ordered set where groupId = ?. 458 * 459 * @param groupId the group ID 460 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 461 * @return the last matching team, or <code>null</code> if a matching team could not be found 462 */ 463 public Team fetchByGroupId_Last(long groupId, 464 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator); 465 466 /** 467 * Returns the teams before and after the current team in the ordered set where groupId = ?. 468 * 469 * @param teamId the primary key of the current team 470 * @param groupId the group ID 471 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 472 * @return the previous, current, and next team 473 * @throws NoSuchTeamException if a team with the primary key could not be found 474 */ 475 public Team[] findByGroupId_PrevAndNext(long teamId, long groupId, 476 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator) 477 throws com.liferay.portal.exception.NoSuchTeamException; 478 479 /** 480 * Returns all the teams that the user has permission to view where groupId = ?. 481 * 482 * @param groupId the group ID 483 * @return the matching teams that the user has permission to view 484 */ 485 public java.util.List<Team> filterFindByGroupId(long groupId); 486 487 /** 488 * Returns a range of all the teams that the user has permission to view where groupId = ?. 489 * 490 * <p> 491 * 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. 492 * </p> 493 * 494 * @param groupId the group ID 495 * @param start the lower bound of the range of teams 496 * @param end the upper bound of the range of teams (not inclusive) 497 * @return the range of matching teams that the user has permission to view 498 */ 499 public java.util.List<Team> filterFindByGroupId(long groupId, int start, 500 int end); 501 502 /** 503 * Returns an ordered range of all the teams that the user has permissions to view where groupId = ?. 504 * 505 * <p> 506 * 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. 507 * </p> 508 * 509 * @param groupId the group ID 510 * @param start the lower bound of the range of teams 511 * @param end the upper bound of the range of teams (not inclusive) 512 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 513 * @return the ordered range of matching teams that the user has permission to view 514 */ 515 public java.util.List<Team> filterFindByGroupId(long groupId, int start, 516 int end, 517 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator); 518 519 /** 520 * Returns the teams before and after the current team in the ordered set of teams that the user has permission to view where groupId = ?. 521 * 522 * @param teamId the primary key of the current team 523 * @param groupId the group ID 524 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 525 * @return the previous, current, and next team 526 * @throws NoSuchTeamException if a team with the primary key could not be found 527 */ 528 public Team[] filterFindByGroupId_PrevAndNext(long teamId, long groupId, 529 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator) 530 throws com.liferay.portal.exception.NoSuchTeamException; 531 532 /** 533 * Removes all the teams where groupId = ? from the database. 534 * 535 * @param groupId the group ID 536 */ 537 public void removeByGroupId(long groupId); 538 539 /** 540 * Returns the number of teams where groupId = ?. 541 * 542 * @param groupId the group ID 543 * @return the number of matching teams 544 */ 545 public int countByGroupId(long groupId); 546 547 /** 548 * Returns the number of teams that the user has permission to view where groupId = ?. 549 * 550 * @param groupId the group ID 551 * @return the number of matching teams that the user has permission to view 552 */ 553 public int filterCountByGroupId(long groupId); 554 555 /** 556 * Returns the team where groupId = ? and name = ? or throws a {@link NoSuchTeamException} if it could not be found. 557 * 558 * @param groupId the group ID 559 * @param name the name 560 * @return the matching team 561 * @throws NoSuchTeamException if a matching team could not be found 562 */ 563 public Team findByG_N(long groupId, java.lang.String name) 564 throws com.liferay.portal.exception.NoSuchTeamException; 565 566 /** 567 * Returns the team where groupId = ? and name = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 568 * 569 * @param groupId the group ID 570 * @param name the name 571 * @return the matching team, or <code>null</code> if a matching team could not be found 572 */ 573 public Team fetchByG_N(long groupId, java.lang.String name); 574 575 /** 576 * Returns the team where groupId = ? and name = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 577 * 578 * @param groupId the group ID 579 * @param name the name 580 * @param retrieveFromCache whether to retrieve from the finder cache 581 * @return the matching team, or <code>null</code> if a matching team could not be found 582 */ 583 public Team fetchByG_N(long groupId, java.lang.String name, 584 boolean retrieveFromCache); 585 586 /** 587 * Removes the team where groupId = ? and name = ? from the database. 588 * 589 * @param groupId the group ID 590 * @param name the name 591 * @return the team that was removed 592 */ 593 public Team removeByG_N(long groupId, java.lang.String name) 594 throws com.liferay.portal.exception.NoSuchTeamException; 595 596 /** 597 * Returns the number of teams where groupId = ? and name = ?. 598 * 599 * @param groupId the group ID 600 * @param name the name 601 * @return the number of matching teams 602 */ 603 public int countByG_N(long groupId, java.lang.String name); 604 605 /** 606 * Caches the team in the entity cache if it is enabled. 607 * 608 * @param team the team 609 */ 610 public void cacheResult(Team team); 611 612 /** 613 * Caches the teams in the entity cache if it is enabled. 614 * 615 * @param teams the teams 616 */ 617 public void cacheResult(java.util.List<Team> teams); 618 619 /** 620 * Creates a new team with the primary key. Does not add the team to the database. 621 * 622 * @param teamId the primary key for the new team 623 * @return the new team 624 */ 625 public Team create(long teamId); 626 627 /** 628 * Removes the team with the primary key from the database. Also notifies the appropriate model listeners. 629 * 630 * @param teamId the primary key of the team 631 * @return the team that was removed 632 * @throws NoSuchTeamException if a team with the primary key could not be found 633 */ 634 public Team remove(long teamId) 635 throws com.liferay.portal.exception.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) 647 throws com.liferay.portal.exception.NoSuchTeamException; 648 649 /** 650 * Returns the team with the primary key or returns <code>null</code> if it could not be found. 651 * 652 * @param teamId the primary key of the team 653 * @return the team, or <code>null</code> if a team with the primary key could not be found 654 */ 655 public Team fetchByPrimaryKey(long teamId); 656 657 @Override 658 public java.util.Map<java.io.Serializable, Team> fetchByPrimaryKeys( 659 java.util.Set<java.io.Serializable> primaryKeys); 660 661 /** 662 * Returns all the teams. 663 * 664 * @return the teams 665 */ 666 public java.util.List<Team> findAll(); 667 668 /** 669 * Returns a range of all the teams. 670 * 671 * <p> 672 * 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. 673 * </p> 674 * 675 * @param start the lower bound of the range of teams 676 * @param end the upper bound of the range of teams (not inclusive) 677 * @return the range of teams 678 */ 679 public java.util.List<Team> findAll(int start, int end); 680 681 /** 682 * Returns an ordered range of all the teams. 683 * 684 * <p> 685 * 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. 686 * </p> 687 * 688 * @param start the lower bound of the range of teams 689 * @param end the upper bound of the range of teams (not inclusive) 690 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 691 * @return the ordered range of teams 692 */ 693 public java.util.List<Team> findAll(int start, int end, 694 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator); 695 696 /** 697 * Returns an ordered range of all the teams. 698 * 699 * <p> 700 * 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. 701 * </p> 702 * 703 * @param start the lower bound of the range of teams 704 * @param end the upper bound of the range of teams (not inclusive) 705 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 706 * @param retrieveFromCache whether to retrieve from the finder cache 707 * @return the ordered range of teams 708 */ 709 public java.util.List<Team> findAll(int start, int end, 710 com.liferay.portal.kernel.util.OrderByComparator<Team> orderByComparator, 711 boolean retrieveFromCache); 712 713 /** 714 * Removes all the teams from the database. 715 */ 716 public void removeAll(); 717 718 /** 719 * Returns the number of teams. 720 * 721 * @return the number of teams 722 */ 723 public int countAll(); 724 725 /** 726 * Returns the primaryKeys of users associated with the team. 727 * 728 * @param pk the primary key of the team 729 * @return long[] of the primaryKeys of users associated with the team 730 */ 731 public long[] getUserPrimaryKeys(long pk); 732 733 /** 734 * Returns all the users associated with the team. 735 * 736 * @param pk the primary key of the team 737 * @return the users associated with the team 738 */ 739 public java.util.List<com.liferay.portal.model.User> getUsers(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.model.User> getUsers(long pk, 754 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.model.User> getUsers(long pk, 770 int start, int end, 771 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.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.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.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.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.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.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.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.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.model.UserGroup> getUserGroups( 934 long pk, int start, int end, 935 com.liferay.portal.kernel.util.OrderByComparator<com.liferay.portal.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.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.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.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.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.model.UserGroup> userGroups); 1053 1054 @Override 1055 public java.util.Set<java.lang.String> getBadColumnNames(); 1056 }