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