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