001 /** 002 * Copyright (c) 2000-2013 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 com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 018 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 019 import com.liferay.portal.kernel.exception.SystemException; 020 import com.liferay.portal.kernel.util.OrderByComparator; 021 import com.liferay.portal.kernel.util.ReferenceRegistry; 022 import com.liferay.portal.model.UserGroup; 023 import com.liferay.portal.service.ServiceContext; 024 025 import java.util.List; 026 027 /** 028 * The persistence utility for the user group service. This utility wraps {@link UserGroupPersistenceImpl} and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class. 029 * 030 * <p> 031 * Caching information and settings can be found in <code>portal.properties</code> 032 * </p> 033 * 034 * @author Brian Wing Shun Chan 035 * @see UserGroupPersistence 036 * @see UserGroupPersistenceImpl 037 * @generated 038 */ 039 public class UserGroupUtil { 040 /* 041 * NOTE FOR DEVELOPERS: 042 * 043 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 044 */ 045 046 /** 047 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 048 */ 049 public static void clearCache() { 050 getPersistence().clearCache(); 051 } 052 053 /** 054 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 055 */ 056 public static void clearCache(UserGroup userGroup) { 057 getPersistence().clearCache(userGroup); 058 } 059 060 /** 061 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 062 */ 063 public long countWithDynamicQuery(DynamicQuery dynamicQuery) 064 throws SystemException { 065 return getPersistence().countWithDynamicQuery(dynamicQuery); 066 } 067 068 /** 069 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 070 */ 071 public static List<UserGroup> findWithDynamicQuery( 072 DynamicQuery dynamicQuery) throws SystemException { 073 return getPersistence().findWithDynamicQuery(dynamicQuery); 074 } 075 076 /** 077 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 078 */ 079 public static List<UserGroup> findWithDynamicQuery( 080 DynamicQuery dynamicQuery, int start, int end) 081 throws SystemException { 082 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 083 } 084 085 /** 086 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 087 */ 088 public static List<UserGroup> findWithDynamicQuery( 089 DynamicQuery dynamicQuery, int start, int end, 090 OrderByComparator orderByComparator) throws SystemException { 091 return getPersistence() 092 .findWithDynamicQuery(dynamicQuery, start, end, 093 orderByComparator); 094 } 095 096 /** 097 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 098 */ 099 public static UserGroup update(UserGroup userGroup) 100 throws SystemException { 101 return getPersistence().update(userGroup); 102 } 103 104 /** 105 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 106 */ 107 public static UserGroup update(UserGroup userGroup, 108 ServiceContext serviceContext) throws SystemException { 109 return getPersistence().update(userGroup, serviceContext); 110 } 111 112 /** 113 * Returns all the user groups where uuid = ?. 114 * 115 * @param uuid the uuid 116 * @return the matching user groups 117 * @throws SystemException if a system exception occurred 118 */ 119 public static java.util.List<com.liferay.portal.model.UserGroup> findByUuid( 120 java.lang.String uuid) 121 throws com.liferay.portal.kernel.exception.SystemException { 122 return getPersistence().findByUuid(uuid); 123 } 124 125 /** 126 * Returns a range of all the user groups where uuid = ?. 127 * 128 * <p> 129 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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. 130 * </p> 131 * 132 * @param uuid the uuid 133 * @param start the lower bound of the range of user groups 134 * @param end the upper bound of the range of user groups (not inclusive) 135 * @return the range of matching user groups 136 * @throws SystemException if a system exception occurred 137 */ 138 public static java.util.List<com.liferay.portal.model.UserGroup> findByUuid( 139 java.lang.String uuid, int start, int end) 140 throws com.liferay.portal.kernel.exception.SystemException { 141 return getPersistence().findByUuid(uuid, start, end); 142 } 143 144 /** 145 * Returns an ordered range of all the user groups where uuid = ?. 146 * 147 * <p> 148 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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. 149 * </p> 150 * 151 * @param uuid the uuid 152 * @param start the lower bound of the range of user groups 153 * @param end the upper bound of the range of user groups (not inclusive) 154 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 155 * @return the ordered range of matching user groups 156 * @throws SystemException if a system exception occurred 157 */ 158 public static java.util.List<com.liferay.portal.model.UserGroup> findByUuid( 159 java.lang.String uuid, int start, int end, 160 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 161 throws com.liferay.portal.kernel.exception.SystemException { 162 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 163 } 164 165 /** 166 * Returns the first user group in the ordered set where uuid = ?. 167 * 168 * @param uuid the uuid 169 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 170 * @return the first matching user group 171 * @throws com.liferay.portal.NoSuchUserGroupException if a matching user group could not be found 172 * @throws SystemException if a system exception occurred 173 */ 174 public static com.liferay.portal.model.UserGroup findByUuid_First( 175 java.lang.String uuid, 176 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 177 throws com.liferay.portal.NoSuchUserGroupException, 178 com.liferay.portal.kernel.exception.SystemException { 179 return getPersistence().findByUuid_First(uuid, orderByComparator); 180 } 181 182 /** 183 * Returns the first user group in the ordered set where uuid = ?. 184 * 185 * @param uuid the uuid 186 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 187 * @return the first matching user group, or <code>null</code> if a matching user group could not be found 188 * @throws SystemException if a system exception occurred 189 */ 190 public static com.liferay.portal.model.UserGroup fetchByUuid_First( 191 java.lang.String uuid, 192 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 193 throws com.liferay.portal.kernel.exception.SystemException { 194 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 195 } 196 197 /** 198 * Returns the last user group in the ordered set where uuid = ?. 199 * 200 * @param uuid the uuid 201 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 202 * @return the last matching user group 203 * @throws com.liferay.portal.NoSuchUserGroupException if a matching user group could not be found 204 * @throws SystemException if a system exception occurred 205 */ 206 public static com.liferay.portal.model.UserGroup findByUuid_Last( 207 java.lang.String uuid, 208 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 209 throws com.liferay.portal.NoSuchUserGroupException, 210 com.liferay.portal.kernel.exception.SystemException { 211 return getPersistence().findByUuid_Last(uuid, orderByComparator); 212 } 213 214 /** 215 * Returns the last user group in the ordered set where uuid = ?. 216 * 217 * @param uuid the uuid 218 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 219 * @return the last matching user group, or <code>null</code> if a matching user group could not be found 220 * @throws SystemException if a system exception occurred 221 */ 222 public static com.liferay.portal.model.UserGroup fetchByUuid_Last( 223 java.lang.String uuid, 224 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 225 throws com.liferay.portal.kernel.exception.SystemException { 226 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 227 } 228 229 /** 230 * Returns the user groups before and after the current user group in the ordered set where uuid = ?. 231 * 232 * @param userGroupId the primary key of the current user group 233 * @param uuid the uuid 234 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 235 * @return the previous, current, and next user group 236 * @throws com.liferay.portal.NoSuchUserGroupException if a user group with the primary key could not be found 237 * @throws SystemException if a system exception occurred 238 */ 239 public static com.liferay.portal.model.UserGroup[] findByUuid_PrevAndNext( 240 long userGroupId, java.lang.String uuid, 241 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 242 throws com.liferay.portal.NoSuchUserGroupException, 243 com.liferay.portal.kernel.exception.SystemException { 244 return getPersistence() 245 .findByUuid_PrevAndNext(userGroupId, uuid, orderByComparator); 246 } 247 248 /** 249 * Returns all the user groups that the user has permission to view where uuid = ?. 250 * 251 * @param uuid the uuid 252 * @return the matching user groups that the user has permission to view 253 * @throws SystemException if a system exception occurred 254 */ 255 public static java.util.List<com.liferay.portal.model.UserGroup> filterFindByUuid( 256 java.lang.String uuid) 257 throws com.liferay.portal.kernel.exception.SystemException { 258 return getPersistence().filterFindByUuid(uuid); 259 } 260 261 /** 262 * Returns a range of all the user groups that the user has permission to view where uuid = ?. 263 * 264 * <p> 265 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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. 266 * </p> 267 * 268 * @param uuid the uuid 269 * @param start the lower bound of the range of user groups 270 * @param end the upper bound of the range of user groups (not inclusive) 271 * @return the range of matching user groups that the user has permission to view 272 * @throws SystemException if a system exception occurred 273 */ 274 public static java.util.List<com.liferay.portal.model.UserGroup> filterFindByUuid( 275 java.lang.String uuid, int start, int end) 276 throws com.liferay.portal.kernel.exception.SystemException { 277 return getPersistence().filterFindByUuid(uuid, start, end); 278 } 279 280 /** 281 * Returns an ordered range of all the user groups that the user has permissions to view where uuid = ?. 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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 start the lower bound of the range of user groups 289 * @param end the upper bound of the range of user groups (not inclusive) 290 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 291 * @return the ordered range of matching user groups that the user has permission to view 292 * @throws SystemException if a system exception occurred 293 */ 294 public static java.util.List<com.liferay.portal.model.UserGroup> filterFindByUuid( 295 java.lang.String uuid, int start, int end, 296 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 297 throws com.liferay.portal.kernel.exception.SystemException { 298 return getPersistence() 299 .filterFindByUuid(uuid, start, end, orderByComparator); 300 } 301 302 /** 303 * 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 = ?. 304 * 305 * @param userGroupId the primary key of the current user group 306 * @param uuid the uuid 307 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 308 * @return the previous, current, and next user group 309 * @throws com.liferay.portal.NoSuchUserGroupException if a user group with the primary key could not be found 310 * @throws SystemException if a system exception occurred 311 */ 312 public static com.liferay.portal.model.UserGroup[] filterFindByUuid_PrevAndNext( 313 long userGroupId, java.lang.String uuid, 314 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 315 throws com.liferay.portal.NoSuchUserGroupException, 316 com.liferay.portal.kernel.exception.SystemException { 317 return getPersistence() 318 .filterFindByUuid_PrevAndNext(userGroupId, uuid, 319 orderByComparator); 320 } 321 322 /** 323 * Removes all the user groups where uuid = ? from the database. 324 * 325 * @param uuid the uuid 326 * @throws SystemException if a system exception occurred 327 */ 328 public static void removeByUuid(java.lang.String uuid) 329 throws com.liferay.portal.kernel.exception.SystemException { 330 getPersistence().removeByUuid(uuid); 331 } 332 333 /** 334 * Returns the number of user groups where uuid = ?. 335 * 336 * @param uuid the uuid 337 * @return the number of matching user groups 338 * @throws SystemException if a system exception occurred 339 */ 340 public static int countByUuid(java.lang.String uuid) 341 throws com.liferay.portal.kernel.exception.SystemException { 342 return getPersistence().countByUuid(uuid); 343 } 344 345 /** 346 * Returns the number of user groups that the user has permission to view where uuid = ?. 347 * 348 * @param uuid the uuid 349 * @return the number of matching user groups that the user has permission to view 350 * @throws SystemException if a system exception occurred 351 */ 352 public static int filterCountByUuid(java.lang.String uuid) 353 throws com.liferay.portal.kernel.exception.SystemException { 354 return getPersistence().filterCountByUuid(uuid); 355 } 356 357 /** 358 * Returns all the user groups where uuid = ? and companyId = ?. 359 * 360 * @param uuid the uuid 361 * @param companyId the company ID 362 * @return the matching user groups 363 * @throws SystemException if a system exception occurred 364 */ 365 public static java.util.List<com.liferay.portal.model.UserGroup> findByUuid_C( 366 java.lang.String uuid, long companyId) 367 throws com.liferay.portal.kernel.exception.SystemException { 368 return getPersistence().findByUuid_C(uuid, companyId); 369 } 370 371 /** 372 * Returns a range of all the user groups where uuid = ? and companyId = ?. 373 * 374 * <p> 375 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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. 376 * </p> 377 * 378 * @param uuid the uuid 379 * @param companyId the company ID 380 * @param start the lower bound of the range of user groups 381 * @param end the upper bound of the range of user groups (not inclusive) 382 * @return the range of matching user groups 383 * @throws SystemException if a system exception occurred 384 */ 385 public static java.util.List<com.liferay.portal.model.UserGroup> findByUuid_C( 386 java.lang.String uuid, long companyId, int start, int end) 387 throws com.liferay.portal.kernel.exception.SystemException { 388 return getPersistence().findByUuid_C(uuid, companyId, start, end); 389 } 390 391 /** 392 * Returns an ordered range of all the user groups where uuid = ? and companyId = ?. 393 * 394 * <p> 395 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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. 396 * </p> 397 * 398 * @param uuid the uuid 399 * @param companyId the company ID 400 * @param start the lower bound of the range of user groups 401 * @param end the upper bound of the range of user groups (not inclusive) 402 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 403 * @return the ordered range of matching user groups 404 * @throws SystemException if a system exception occurred 405 */ 406 public static java.util.List<com.liferay.portal.model.UserGroup> findByUuid_C( 407 java.lang.String uuid, long companyId, int start, int end, 408 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 409 throws com.liferay.portal.kernel.exception.SystemException { 410 return getPersistence() 411 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 412 } 413 414 /** 415 * Returns the first user group in the ordered set where uuid = ? and companyId = ?. 416 * 417 * @param uuid the uuid 418 * @param companyId the company ID 419 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 420 * @return the first matching user group 421 * @throws com.liferay.portal.NoSuchUserGroupException if a matching user group could not be found 422 * @throws SystemException if a system exception occurred 423 */ 424 public static com.liferay.portal.model.UserGroup findByUuid_C_First( 425 java.lang.String uuid, long companyId, 426 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 427 throws com.liferay.portal.NoSuchUserGroupException, 428 com.liferay.portal.kernel.exception.SystemException { 429 return getPersistence() 430 .findByUuid_C_First(uuid, companyId, orderByComparator); 431 } 432 433 /** 434 * Returns the first user group in the ordered set where uuid = ? and companyId = ?. 435 * 436 * @param uuid the uuid 437 * @param companyId the company ID 438 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 439 * @return the first matching user group, or <code>null</code> if a matching user group could not be found 440 * @throws SystemException if a system exception occurred 441 */ 442 public static com.liferay.portal.model.UserGroup fetchByUuid_C_First( 443 java.lang.String uuid, long companyId, 444 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 445 throws com.liferay.portal.kernel.exception.SystemException { 446 return getPersistence() 447 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 448 } 449 450 /** 451 * Returns the last user group in the ordered set where uuid = ? and companyId = ?. 452 * 453 * @param uuid the uuid 454 * @param companyId the company ID 455 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 456 * @return the last matching user group 457 * @throws com.liferay.portal.NoSuchUserGroupException if a matching user group could not be found 458 * @throws SystemException if a system exception occurred 459 */ 460 public static com.liferay.portal.model.UserGroup findByUuid_C_Last( 461 java.lang.String uuid, long companyId, 462 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 463 throws com.liferay.portal.NoSuchUserGroupException, 464 com.liferay.portal.kernel.exception.SystemException { 465 return getPersistence() 466 .findByUuid_C_Last(uuid, companyId, orderByComparator); 467 } 468 469 /** 470 * Returns the last user group in the ordered set where uuid = ? and companyId = ?. 471 * 472 * @param uuid the uuid 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, or <code>null</code> if a matching user group could not be found 476 * @throws SystemException if a system exception occurred 477 */ 478 public static com.liferay.portal.model.UserGroup fetchByUuid_C_Last( 479 java.lang.String uuid, long companyId, 480 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 481 throws com.liferay.portal.kernel.exception.SystemException { 482 return getPersistence() 483 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 484 } 485 486 /** 487 * Returns the user groups before and after the current user group in the ordered set where uuid = ? and companyId = ?. 488 * 489 * @param userGroupId the primary key of the current user group 490 * @param uuid the uuid 491 * @param companyId the company ID 492 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 493 * @return the previous, current, and next user group 494 * @throws com.liferay.portal.NoSuchUserGroupException if a user group with the primary key could not be found 495 * @throws SystemException if a system exception occurred 496 */ 497 public static com.liferay.portal.model.UserGroup[] findByUuid_C_PrevAndNext( 498 long userGroupId, java.lang.String uuid, long companyId, 499 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 500 throws com.liferay.portal.NoSuchUserGroupException, 501 com.liferay.portal.kernel.exception.SystemException { 502 return getPersistence() 503 .findByUuid_C_PrevAndNext(userGroupId, uuid, companyId, 504 orderByComparator); 505 } 506 507 /** 508 * Returns all the user groups that the user has permission to view where uuid = ? and companyId = ?. 509 * 510 * @param uuid the uuid 511 * @param companyId the company ID 512 * @return the matching user groups that the user has permission to view 513 * @throws SystemException if a system exception occurred 514 */ 515 public static java.util.List<com.liferay.portal.model.UserGroup> filterFindByUuid_C( 516 java.lang.String uuid, long companyId) 517 throws com.liferay.portal.kernel.exception.SystemException { 518 return getPersistence().filterFindByUuid_C(uuid, companyId); 519 } 520 521 /** 522 * Returns a range of all the user groups that the user has permission to view where uuid = ? and companyId = ?. 523 * 524 * <p> 525 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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. 526 * </p> 527 * 528 * @param uuid the uuid 529 * @param companyId the company ID 530 * @param start the lower bound of the range of user groups 531 * @param end the upper bound of the range of user groups (not inclusive) 532 * @return the range of matching user groups that the user has permission to view 533 * @throws SystemException if a system exception occurred 534 */ 535 public static java.util.List<com.liferay.portal.model.UserGroup> filterFindByUuid_C( 536 java.lang.String uuid, long companyId, int start, int end) 537 throws com.liferay.portal.kernel.exception.SystemException { 538 return getPersistence().filterFindByUuid_C(uuid, companyId, start, end); 539 } 540 541 /** 542 * Returns an ordered range of all the user groups that the user has permissions to view where uuid = ? and companyId = ?. 543 * 544 * <p> 545 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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. 546 * </p> 547 * 548 * @param uuid the uuid 549 * @param companyId the company ID 550 * @param start the lower bound of the range of user groups 551 * @param end the upper bound of the range of user groups (not inclusive) 552 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 553 * @return the ordered range of matching user groups that the user has permission to view 554 * @throws SystemException if a system exception occurred 555 */ 556 public static java.util.List<com.liferay.portal.model.UserGroup> filterFindByUuid_C( 557 java.lang.String uuid, long companyId, int start, int end, 558 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 559 throws com.liferay.portal.kernel.exception.SystemException { 560 return getPersistence() 561 .filterFindByUuid_C(uuid, companyId, start, end, 562 orderByComparator); 563 } 564 565 /** 566 * 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 = ?. 567 * 568 * @param userGroupId the primary key of the current user group 569 * @param uuid the uuid 570 * @param companyId the company ID 571 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 572 * @return the previous, current, and next user group 573 * @throws com.liferay.portal.NoSuchUserGroupException if a user group with the primary key could not be found 574 * @throws SystemException if a system exception occurred 575 */ 576 public static com.liferay.portal.model.UserGroup[] filterFindByUuid_C_PrevAndNext( 577 long userGroupId, java.lang.String uuid, long companyId, 578 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 579 throws com.liferay.portal.NoSuchUserGroupException, 580 com.liferay.portal.kernel.exception.SystemException { 581 return getPersistence() 582 .filterFindByUuid_C_PrevAndNext(userGroupId, uuid, 583 companyId, orderByComparator); 584 } 585 586 /** 587 * Removes all the user groups where uuid = ? and companyId = ? from the database. 588 * 589 * @param uuid the uuid 590 * @param companyId the company ID 591 * @throws SystemException if a system exception occurred 592 */ 593 public static void removeByUuid_C(java.lang.String uuid, long companyId) 594 throws com.liferay.portal.kernel.exception.SystemException { 595 getPersistence().removeByUuid_C(uuid, companyId); 596 } 597 598 /** 599 * Returns the number of user groups where uuid = ? and companyId = ?. 600 * 601 * @param uuid the uuid 602 * @param companyId the company ID 603 * @return the number of matching user groups 604 * @throws SystemException if a system exception occurred 605 */ 606 public static int countByUuid_C(java.lang.String uuid, long companyId) 607 throws com.liferay.portal.kernel.exception.SystemException { 608 return getPersistence().countByUuid_C(uuid, companyId); 609 } 610 611 /** 612 * Returns the number of user groups that the user has permission to view where uuid = ? and companyId = ?. 613 * 614 * @param uuid the uuid 615 * @param companyId the company ID 616 * @return the number of matching user groups that the user has permission to view 617 * @throws SystemException if a system exception occurred 618 */ 619 public static int filterCountByUuid_C(java.lang.String uuid, long companyId) 620 throws com.liferay.portal.kernel.exception.SystemException { 621 return getPersistence().filterCountByUuid_C(uuid, companyId); 622 } 623 624 /** 625 * Returns all the user groups where companyId = ?. 626 * 627 * @param companyId the company ID 628 * @return the matching user groups 629 * @throws SystemException if a system exception occurred 630 */ 631 public static java.util.List<com.liferay.portal.model.UserGroup> findByCompanyId( 632 long companyId) 633 throws com.liferay.portal.kernel.exception.SystemException { 634 return getPersistence().findByCompanyId(companyId); 635 } 636 637 /** 638 * Returns a range of all the user groups where companyId = ?. 639 * 640 * <p> 641 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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. 642 * </p> 643 * 644 * @param companyId the company ID 645 * @param start the lower bound of the range of user groups 646 * @param end the upper bound of the range of user groups (not inclusive) 647 * @return the range of matching user groups 648 * @throws SystemException if a system exception occurred 649 */ 650 public static java.util.List<com.liferay.portal.model.UserGroup> findByCompanyId( 651 long companyId, int start, int end) 652 throws com.liferay.portal.kernel.exception.SystemException { 653 return getPersistence().findByCompanyId(companyId, start, end); 654 } 655 656 /** 657 * Returns an ordered range of all the user groups where companyId = ?. 658 * 659 * <p> 660 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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. 661 * </p> 662 * 663 * @param companyId the company ID 664 * @param start the lower bound of the range of user groups 665 * @param end the upper bound of the range of user groups (not inclusive) 666 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 667 * @return the ordered range of matching user groups 668 * @throws SystemException if a system exception occurred 669 */ 670 public static java.util.List<com.liferay.portal.model.UserGroup> findByCompanyId( 671 long companyId, int start, int end, 672 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 673 throws com.liferay.portal.kernel.exception.SystemException { 674 return getPersistence() 675 .findByCompanyId(companyId, start, end, orderByComparator); 676 } 677 678 /** 679 * Returns the first user group in the ordered set where companyId = ?. 680 * 681 * @param companyId the company ID 682 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 683 * @return the first matching user group 684 * @throws com.liferay.portal.NoSuchUserGroupException if a matching user group could not be found 685 * @throws SystemException if a system exception occurred 686 */ 687 public static com.liferay.portal.model.UserGroup findByCompanyId_First( 688 long companyId, 689 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 690 throws com.liferay.portal.NoSuchUserGroupException, 691 com.liferay.portal.kernel.exception.SystemException { 692 return getPersistence() 693 .findByCompanyId_First(companyId, orderByComparator); 694 } 695 696 /** 697 * Returns the first user group in the ordered set where companyId = ?. 698 * 699 * @param companyId the company ID 700 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 701 * @return the first matching user group, or <code>null</code> if a matching user group could not be found 702 * @throws SystemException if a system exception occurred 703 */ 704 public static com.liferay.portal.model.UserGroup fetchByCompanyId_First( 705 long companyId, 706 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 707 throws com.liferay.portal.kernel.exception.SystemException { 708 return getPersistence() 709 .fetchByCompanyId_First(companyId, orderByComparator); 710 } 711 712 /** 713 * Returns the last user group in the ordered set where companyId = ?. 714 * 715 * @param companyId the company ID 716 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 717 * @return the last matching user group 718 * @throws com.liferay.portal.NoSuchUserGroupException if a matching user group could not be found 719 * @throws SystemException if a system exception occurred 720 */ 721 public static com.liferay.portal.model.UserGroup findByCompanyId_Last( 722 long companyId, 723 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 724 throws com.liferay.portal.NoSuchUserGroupException, 725 com.liferay.portal.kernel.exception.SystemException { 726 return getPersistence() 727 .findByCompanyId_Last(companyId, orderByComparator); 728 } 729 730 /** 731 * Returns the last user group in the ordered set where companyId = ?. 732 * 733 * @param companyId the company ID 734 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 735 * @return the last matching user group, or <code>null</code> if a matching user group could not be found 736 * @throws SystemException if a system exception occurred 737 */ 738 public static com.liferay.portal.model.UserGroup fetchByCompanyId_Last( 739 long companyId, 740 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 741 throws com.liferay.portal.kernel.exception.SystemException { 742 return getPersistence() 743 .fetchByCompanyId_Last(companyId, orderByComparator); 744 } 745 746 /** 747 * Returns the user groups before and after the current user group in the ordered set where companyId = ?. 748 * 749 * @param userGroupId the primary key of the current user group 750 * @param companyId the company ID 751 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 752 * @return the previous, current, and next user group 753 * @throws com.liferay.portal.NoSuchUserGroupException if a user group with the primary key could not be found 754 * @throws SystemException if a system exception occurred 755 */ 756 public static com.liferay.portal.model.UserGroup[] findByCompanyId_PrevAndNext( 757 long userGroupId, long companyId, 758 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 759 throws com.liferay.portal.NoSuchUserGroupException, 760 com.liferay.portal.kernel.exception.SystemException { 761 return getPersistence() 762 .findByCompanyId_PrevAndNext(userGroupId, companyId, 763 orderByComparator); 764 } 765 766 /** 767 * Returns all the user groups that the user has permission to view where companyId = ?. 768 * 769 * @param companyId the company ID 770 * @return the matching user groups that the user has permission to view 771 * @throws SystemException if a system exception occurred 772 */ 773 public static java.util.List<com.liferay.portal.model.UserGroup> filterFindByCompanyId( 774 long companyId) 775 throws com.liferay.portal.kernel.exception.SystemException { 776 return getPersistence().filterFindByCompanyId(companyId); 777 } 778 779 /** 780 * Returns a range of all the user groups that the user has permission to view where companyId = ?. 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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 start the lower bound of the range of user groups 788 * @param end the upper bound of the range of user groups (not inclusive) 789 * @return the range of matching user groups that the user has permission to view 790 * @throws SystemException if a system exception occurred 791 */ 792 public static java.util.List<com.liferay.portal.model.UserGroup> filterFindByCompanyId( 793 long companyId, int start, int end) 794 throws com.liferay.portal.kernel.exception.SystemException { 795 return getPersistence().filterFindByCompanyId(companyId, start, end); 796 } 797 798 /** 799 * Returns an ordered range of all the user groups that the user has permissions to view where companyId = ?. 800 * 801 * <p> 802 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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. 803 * </p> 804 * 805 * @param companyId the company ID 806 * @param start the lower bound of the range of user groups 807 * @param end the upper bound of the range of user groups (not inclusive) 808 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 809 * @return the ordered range of matching user groups that the user has permission to view 810 * @throws SystemException if a system exception occurred 811 */ 812 public static java.util.List<com.liferay.portal.model.UserGroup> filterFindByCompanyId( 813 long companyId, int start, int end, 814 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 815 throws com.liferay.portal.kernel.exception.SystemException { 816 return getPersistence() 817 .filterFindByCompanyId(companyId, start, end, 818 orderByComparator); 819 } 820 821 /** 822 * 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 = ?. 823 * 824 * @param userGroupId the primary key of the current user group 825 * @param companyId the company ID 826 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 827 * @return the previous, current, and next user group 828 * @throws com.liferay.portal.NoSuchUserGroupException if a user group with the primary key could not be found 829 * @throws SystemException if a system exception occurred 830 */ 831 public static com.liferay.portal.model.UserGroup[] filterFindByCompanyId_PrevAndNext( 832 long userGroupId, long companyId, 833 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 834 throws com.liferay.portal.NoSuchUserGroupException, 835 com.liferay.portal.kernel.exception.SystemException { 836 return getPersistence() 837 .filterFindByCompanyId_PrevAndNext(userGroupId, companyId, 838 orderByComparator); 839 } 840 841 /** 842 * Removes all the user groups where companyId = ? from the database. 843 * 844 * @param companyId the company ID 845 * @throws SystemException if a system exception occurred 846 */ 847 public static void removeByCompanyId(long companyId) 848 throws com.liferay.portal.kernel.exception.SystemException { 849 getPersistence().removeByCompanyId(companyId); 850 } 851 852 /** 853 * Returns the number of user groups where companyId = ?. 854 * 855 * @param companyId the company ID 856 * @return the number of matching user groups 857 * @throws SystemException if a system exception occurred 858 */ 859 public static int countByCompanyId(long companyId) 860 throws com.liferay.portal.kernel.exception.SystemException { 861 return getPersistence().countByCompanyId(companyId); 862 } 863 864 /** 865 * Returns the number of user groups that the user has permission to view where companyId = ?. 866 * 867 * @param companyId the company ID 868 * @return the number of matching user groups that the user has permission to view 869 * @throws SystemException if a system exception occurred 870 */ 871 public static int filterCountByCompanyId(long companyId) 872 throws com.liferay.portal.kernel.exception.SystemException { 873 return getPersistence().filterCountByCompanyId(companyId); 874 } 875 876 /** 877 * Returns all the user groups where companyId = ? and parentUserGroupId = ?. 878 * 879 * @param companyId the company ID 880 * @param parentUserGroupId the parent user group ID 881 * @return the matching user groups 882 * @throws SystemException if a system exception occurred 883 */ 884 public static java.util.List<com.liferay.portal.model.UserGroup> findByC_P( 885 long companyId, long parentUserGroupId) 886 throws com.liferay.portal.kernel.exception.SystemException { 887 return getPersistence().findByC_P(companyId, parentUserGroupId); 888 } 889 890 /** 891 * Returns a range of all the user groups where companyId = ? and parentUserGroupId = ?. 892 * 893 * <p> 894 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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. 895 * </p> 896 * 897 * @param companyId the company ID 898 * @param parentUserGroupId the parent user group ID 899 * @param start the lower bound of the range of user groups 900 * @param end the upper bound of the range of user groups (not inclusive) 901 * @return the range of matching user groups 902 * @throws SystemException if a system exception occurred 903 */ 904 public static java.util.List<com.liferay.portal.model.UserGroup> findByC_P( 905 long companyId, long parentUserGroupId, int start, int end) 906 throws com.liferay.portal.kernel.exception.SystemException { 907 return getPersistence() 908 .findByC_P(companyId, parentUserGroupId, start, end); 909 } 910 911 /** 912 * Returns an ordered range of all the user groups where companyId = ? and parentUserGroupId = ?. 913 * 914 * <p> 915 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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. 916 * </p> 917 * 918 * @param companyId the company ID 919 * @param parentUserGroupId the parent user group ID 920 * @param start the lower bound of the range of user groups 921 * @param end the upper bound of the range of user groups (not inclusive) 922 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 923 * @return the ordered range of matching user groups 924 * @throws SystemException if a system exception occurred 925 */ 926 public static java.util.List<com.liferay.portal.model.UserGroup> findByC_P( 927 long companyId, long parentUserGroupId, int start, int end, 928 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 929 throws com.liferay.portal.kernel.exception.SystemException { 930 return getPersistence() 931 .findByC_P(companyId, parentUserGroupId, start, end, 932 orderByComparator); 933 } 934 935 /** 936 * Returns the first user group in the ordered set where companyId = ? and parentUserGroupId = ?. 937 * 938 * @param companyId the company ID 939 * @param parentUserGroupId the parent user group ID 940 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 941 * @return the first matching user group 942 * @throws com.liferay.portal.NoSuchUserGroupException if a matching user group could not be found 943 * @throws SystemException if a system exception occurred 944 */ 945 public static com.liferay.portal.model.UserGroup findByC_P_First( 946 long companyId, long parentUserGroupId, 947 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 948 throws com.liferay.portal.NoSuchUserGroupException, 949 com.liferay.portal.kernel.exception.SystemException { 950 return getPersistence() 951 .findByC_P_First(companyId, parentUserGroupId, 952 orderByComparator); 953 } 954 955 /** 956 * Returns the first user group in the ordered set where companyId = ? and parentUserGroupId = ?. 957 * 958 * @param companyId the company ID 959 * @param parentUserGroupId the parent user group ID 960 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 961 * @return the first matching user group, or <code>null</code> if a matching user group could not be found 962 * @throws SystemException if a system exception occurred 963 */ 964 public static com.liferay.portal.model.UserGroup fetchByC_P_First( 965 long companyId, long parentUserGroupId, 966 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 967 throws com.liferay.portal.kernel.exception.SystemException { 968 return getPersistence() 969 .fetchByC_P_First(companyId, parentUserGroupId, 970 orderByComparator); 971 } 972 973 /** 974 * Returns the last user group in the ordered set where companyId = ? and parentUserGroupId = ?. 975 * 976 * @param companyId the company ID 977 * @param parentUserGroupId the parent user group ID 978 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 979 * @return the last matching user group 980 * @throws com.liferay.portal.NoSuchUserGroupException if a matching user group could not be found 981 * @throws SystemException if a system exception occurred 982 */ 983 public static com.liferay.portal.model.UserGroup findByC_P_Last( 984 long companyId, long parentUserGroupId, 985 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 986 throws com.liferay.portal.NoSuchUserGroupException, 987 com.liferay.portal.kernel.exception.SystemException { 988 return getPersistence() 989 .findByC_P_Last(companyId, parentUserGroupId, 990 orderByComparator); 991 } 992 993 /** 994 * Returns the last user group in the ordered set where companyId = ? and parentUserGroupId = ?. 995 * 996 * @param companyId the company ID 997 * @param parentUserGroupId the parent user group ID 998 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 999 * @return the last matching user group, or <code>null</code> if a matching user group could not be found 1000 * @throws SystemException if a system exception occurred 1001 */ 1002 public static com.liferay.portal.model.UserGroup fetchByC_P_Last( 1003 long companyId, long parentUserGroupId, 1004 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1005 throws com.liferay.portal.kernel.exception.SystemException { 1006 return getPersistence() 1007 .fetchByC_P_Last(companyId, parentUserGroupId, 1008 orderByComparator); 1009 } 1010 1011 /** 1012 * Returns the user groups before and after the current user group in the ordered set where companyId = ? and parentUserGroupId = ?. 1013 * 1014 * @param userGroupId the primary key of the current user group 1015 * @param companyId the company ID 1016 * @param parentUserGroupId the parent user group ID 1017 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1018 * @return the previous, current, and next user group 1019 * @throws com.liferay.portal.NoSuchUserGroupException if a user group with the primary key could not be found 1020 * @throws SystemException if a system exception occurred 1021 */ 1022 public static com.liferay.portal.model.UserGroup[] findByC_P_PrevAndNext( 1023 long userGroupId, long companyId, long parentUserGroupId, 1024 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1025 throws com.liferay.portal.NoSuchUserGroupException, 1026 com.liferay.portal.kernel.exception.SystemException { 1027 return getPersistence() 1028 .findByC_P_PrevAndNext(userGroupId, companyId, 1029 parentUserGroupId, orderByComparator); 1030 } 1031 1032 /** 1033 * Returns all the user groups that the user has permission to view where companyId = ? and parentUserGroupId = ?. 1034 * 1035 * @param companyId the company ID 1036 * @param parentUserGroupId the parent user group ID 1037 * @return the matching user groups that the user has permission to view 1038 * @throws SystemException if a system exception occurred 1039 */ 1040 public static java.util.List<com.liferay.portal.model.UserGroup> filterFindByC_P( 1041 long companyId, long parentUserGroupId) 1042 throws com.liferay.portal.kernel.exception.SystemException { 1043 return getPersistence().filterFindByC_P(companyId, parentUserGroupId); 1044 } 1045 1046 /** 1047 * Returns a range of all the user groups that the user has permission to view where companyId = ? and parentUserGroupId = ?. 1048 * 1049 * <p> 1050 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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. 1051 * </p> 1052 * 1053 * @param companyId the company ID 1054 * @param parentUserGroupId the parent user group ID 1055 * @param start the lower bound of the range of user groups 1056 * @param end the upper bound of the range of user groups (not inclusive) 1057 * @return the range of matching user groups that the user has permission to view 1058 * @throws SystemException if a system exception occurred 1059 */ 1060 public static java.util.List<com.liferay.portal.model.UserGroup> filterFindByC_P( 1061 long companyId, long parentUserGroupId, int start, int end) 1062 throws com.liferay.portal.kernel.exception.SystemException { 1063 return getPersistence() 1064 .filterFindByC_P(companyId, parentUserGroupId, start, end); 1065 } 1066 1067 /** 1068 * Returns an ordered range of all the user groups that the user has permissions to view where companyId = ? and parentUserGroupId = ?. 1069 * 1070 * <p> 1071 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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. 1072 * </p> 1073 * 1074 * @param companyId the company ID 1075 * @param parentUserGroupId the parent user group ID 1076 * @param start the lower bound of the range of user groups 1077 * @param end the upper bound of the range of user groups (not inclusive) 1078 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1079 * @return the ordered range of matching user groups that the user has permission to view 1080 * @throws SystemException if a system exception occurred 1081 */ 1082 public static java.util.List<com.liferay.portal.model.UserGroup> filterFindByC_P( 1083 long companyId, long parentUserGroupId, int start, int end, 1084 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1085 throws com.liferay.portal.kernel.exception.SystemException { 1086 return getPersistence() 1087 .filterFindByC_P(companyId, parentUserGroupId, start, end, 1088 orderByComparator); 1089 } 1090 1091 /** 1092 * 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 = ?. 1093 * 1094 * @param userGroupId the primary key of the current user group 1095 * @param companyId the company ID 1096 * @param parentUserGroupId the parent user group ID 1097 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1098 * @return the previous, current, and next user group 1099 * @throws com.liferay.portal.NoSuchUserGroupException if a user group with the primary key could not be found 1100 * @throws SystemException if a system exception occurred 1101 */ 1102 public static com.liferay.portal.model.UserGroup[] filterFindByC_P_PrevAndNext( 1103 long userGroupId, long companyId, long parentUserGroupId, 1104 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1105 throws com.liferay.portal.NoSuchUserGroupException, 1106 com.liferay.portal.kernel.exception.SystemException { 1107 return getPersistence() 1108 .filterFindByC_P_PrevAndNext(userGroupId, companyId, 1109 parentUserGroupId, orderByComparator); 1110 } 1111 1112 /** 1113 * Removes all the user groups where companyId = ? and parentUserGroupId = ? from the database. 1114 * 1115 * @param companyId the company ID 1116 * @param parentUserGroupId the parent user group ID 1117 * @throws SystemException if a system exception occurred 1118 */ 1119 public static void removeByC_P(long companyId, long parentUserGroupId) 1120 throws com.liferay.portal.kernel.exception.SystemException { 1121 getPersistence().removeByC_P(companyId, parentUserGroupId); 1122 } 1123 1124 /** 1125 * Returns the number of user groups where companyId = ? and parentUserGroupId = ?. 1126 * 1127 * @param companyId the company ID 1128 * @param parentUserGroupId the parent user group ID 1129 * @return the number of matching user groups 1130 * @throws SystemException if a system exception occurred 1131 */ 1132 public static int countByC_P(long companyId, long parentUserGroupId) 1133 throws com.liferay.portal.kernel.exception.SystemException { 1134 return getPersistence().countByC_P(companyId, parentUserGroupId); 1135 } 1136 1137 /** 1138 * Returns the number of user groups that the user has permission to view where companyId = ? and parentUserGroupId = ?. 1139 * 1140 * @param companyId the company ID 1141 * @param parentUserGroupId the parent user group ID 1142 * @return the number of matching user groups that the user has permission to view 1143 * @throws SystemException if a system exception occurred 1144 */ 1145 public static int filterCountByC_P(long companyId, long parentUserGroupId) 1146 throws com.liferay.portal.kernel.exception.SystemException { 1147 return getPersistence().filterCountByC_P(companyId, parentUserGroupId); 1148 } 1149 1150 /** 1151 * Returns the user group where companyId = ? and name = ? or throws a {@link com.liferay.portal.NoSuchUserGroupException} if it could not be found. 1152 * 1153 * @param companyId the company ID 1154 * @param name the name 1155 * @return the matching user group 1156 * @throws com.liferay.portal.NoSuchUserGroupException if a matching user group could not be found 1157 * @throws SystemException if a system exception occurred 1158 */ 1159 public static com.liferay.portal.model.UserGroup findByC_N(long companyId, 1160 java.lang.String name) 1161 throws com.liferay.portal.NoSuchUserGroupException, 1162 com.liferay.portal.kernel.exception.SystemException { 1163 return getPersistence().findByC_N(companyId, name); 1164 } 1165 1166 /** 1167 * Returns the user group where companyId = ? and name = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 1168 * 1169 * @param companyId the company ID 1170 * @param name the name 1171 * @return the matching user group, or <code>null</code> if a matching user group could not be found 1172 * @throws SystemException if a system exception occurred 1173 */ 1174 public static com.liferay.portal.model.UserGroup fetchByC_N( 1175 long companyId, java.lang.String name) 1176 throws com.liferay.portal.kernel.exception.SystemException { 1177 return getPersistence().fetchByC_N(companyId, name); 1178 } 1179 1180 /** 1181 * Returns the user group where companyId = ? and name = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 1182 * 1183 * @param companyId the company ID 1184 * @param name the name 1185 * @param retrieveFromCache whether to use the finder cache 1186 * @return the matching user group, or <code>null</code> if a matching user group could not be found 1187 * @throws SystemException if a system exception occurred 1188 */ 1189 public static com.liferay.portal.model.UserGroup fetchByC_N( 1190 long companyId, java.lang.String name, boolean retrieveFromCache) 1191 throws com.liferay.portal.kernel.exception.SystemException { 1192 return getPersistence().fetchByC_N(companyId, name, retrieveFromCache); 1193 } 1194 1195 /** 1196 * Removes the user group where companyId = ? and name = ? from the database. 1197 * 1198 * @param companyId the company ID 1199 * @param name the name 1200 * @return the user group that was removed 1201 * @throws SystemException if a system exception occurred 1202 */ 1203 public static com.liferay.portal.model.UserGroup removeByC_N( 1204 long companyId, java.lang.String name) 1205 throws com.liferay.portal.NoSuchUserGroupException, 1206 com.liferay.portal.kernel.exception.SystemException { 1207 return getPersistence().removeByC_N(companyId, name); 1208 } 1209 1210 /** 1211 * Returns the number of user groups where companyId = ? and name = ?. 1212 * 1213 * @param companyId the company ID 1214 * @param name the name 1215 * @return the number of matching user groups 1216 * @throws SystemException if a system exception occurred 1217 */ 1218 public static int countByC_N(long companyId, java.lang.String name) 1219 throws com.liferay.portal.kernel.exception.SystemException { 1220 return getPersistence().countByC_N(companyId, name); 1221 } 1222 1223 /** 1224 * Caches the user group in the entity cache if it is enabled. 1225 * 1226 * @param userGroup the user group 1227 */ 1228 public static void cacheResult(com.liferay.portal.model.UserGroup userGroup) { 1229 getPersistence().cacheResult(userGroup); 1230 } 1231 1232 /** 1233 * Caches the user groups in the entity cache if it is enabled. 1234 * 1235 * @param userGroups the user groups 1236 */ 1237 public static void cacheResult( 1238 java.util.List<com.liferay.portal.model.UserGroup> userGroups) { 1239 getPersistence().cacheResult(userGroups); 1240 } 1241 1242 /** 1243 * Creates a new user group with the primary key. Does not add the user group to the database. 1244 * 1245 * @param userGroupId the primary key for the new user group 1246 * @return the new user group 1247 */ 1248 public static com.liferay.portal.model.UserGroup create(long userGroupId) { 1249 return getPersistence().create(userGroupId); 1250 } 1251 1252 /** 1253 * Removes the user group with the primary key from the database. Also notifies the appropriate model listeners. 1254 * 1255 * @param userGroupId the primary key of the user group 1256 * @return the user group that was removed 1257 * @throws com.liferay.portal.NoSuchUserGroupException if a user group with the primary key could not be found 1258 * @throws SystemException if a system exception occurred 1259 */ 1260 public static com.liferay.portal.model.UserGroup remove(long userGroupId) 1261 throws com.liferay.portal.NoSuchUserGroupException, 1262 com.liferay.portal.kernel.exception.SystemException { 1263 return getPersistence().remove(userGroupId); 1264 } 1265 1266 public static com.liferay.portal.model.UserGroup updateImpl( 1267 com.liferay.portal.model.UserGroup userGroup) 1268 throws com.liferay.portal.kernel.exception.SystemException { 1269 return getPersistence().updateImpl(userGroup); 1270 } 1271 1272 /** 1273 * Returns the user group with the primary key or throws a {@link com.liferay.portal.NoSuchUserGroupException} if it could not be found. 1274 * 1275 * @param userGroupId the primary key of the user group 1276 * @return the user group 1277 * @throws com.liferay.portal.NoSuchUserGroupException if a user group with the primary key could not be found 1278 * @throws SystemException if a system exception occurred 1279 */ 1280 public static com.liferay.portal.model.UserGroup findByPrimaryKey( 1281 long userGroupId) 1282 throws com.liferay.portal.NoSuchUserGroupException, 1283 com.liferay.portal.kernel.exception.SystemException { 1284 return getPersistence().findByPrimaryKey(userGroupId); 1285 } 1286 1287 /** 1288 * Returns the user group with the primary key or returns <code>null</code> if it could not be found. 1289 * 1290 * @param userGroupId the primary key of the user group 1291 * @return the user group, or <code>null</code> if a user group with the primary key could not be found 1292 * @throws SystemException if a system exception occurred 1293 */ 1294 public static com.liferay.portal.model.UserGroup fetchByPrimaryKey( 1295 long userGroupId) 1296 throws com.liferay.portal.kernel.exception.SystemException { 1297 return getPersistence().fetchByPrimaryKey(userGroupId); 1298 } 1299 1300 /** 1301 * Returns all the user groups. 1302 * 1303 * @return the user groups 1304 * @throws SystemException if a system exception occurred 1305 */ 1306 public static java.util.List<com.liferay.portal.model.UserGroup> findAll() 1307 throws com.liferay.portal.kernel.exception.SystemException { 1308 return getPersistence().findAll(); 1309 } 1310 1311 /** 1312 * Returns a range of all the user groups. 1313 * 1314 * <p> 1315 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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. 1316 * </p> 1317 * 1318 * @param start the lower bound of the range of user groups 1319 * @param end the upper bound of the range of user groups (not inclusive) 1320 * @return the range of user groups 1321 * @throws SystemException if a system exception occurred 1322 */ 1323 public static java.util.List<com.liferay.portal.model.UserGroup> findAll( 1324 int start, int end) 1325 throws com.liferay.portal.kernel.exception.SystemException { 1326 return getPersistence().findAll(start, end); 1327 } 1328 1329 /** 1330 * Returns an ordered range of all the user groups. 1331 * 1332 * <p> 1333 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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. 1334 * </p> 1335 * 1336 * @param start the lower bound of the range of user groups 1337 * @param end the upper bound of the range of user groups (not inclusive) 1338 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1339 * @return the ordered range of user groups 1340 * @throws SystemException if a system exception occurred 1341 */ 1342 public static java.util.List<com.liferay.portal.model.UserGroup> findAll( 1343 int start, int end, 1344 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1345 throws com.liferay.portal.kernel.exception.SystemException { 1346 return getPersistence().findAll(start, end, orderByComparator); 1347 } 1348 1349 /** 1350 * Removes all the user groups from the database. 1351 * 1352 * @throws SystemException if a system exception occurred 1353 */ 1354 public static void removeAll() 1355 throws com.liferay.portal.kernel.exception.SystemException { 1356 getPersistence().removeAll(); 1357 } 1358 1359 /** 1360 * Returns the number of user groups. 1361 * 1362 * @return the number of user groups 1363 * @throws SystemException if a system exception occurred 1364 */ 1365 public static int countAll() 1366 throws com.liferay.portal.kernel.exception.SystemException { 1367 return getPersistence().countAll(); 1368 } 1369 1370 /** 1371 * Returns all the groups associated with the user group. 1372 * 1373 * @param pk the primary key of the user group 1374 * @return the groups associated with the user group 1375 * @throws SystemException if a system exception occurred 1376 */ 1377 public static java.util.List<com.liferay.portal.model.Group> getGroups( 1378 long pk) throws com.liferay.portal.kernel.exception.SystemException { 1379 return getPersistence().getGroups(pk); 1380 } 1381 1382 /** 1383 * Returns a range of all the groups associated with the user group. 1384 * 1385 * <p> 1386 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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. 1387 * </p> 1388 * 1389 * @param pk the primary key of the user group 1390 * @param start the lower bound of the range of user groups 1391 * @param end the upper bound of the range of user groups (not inclusive) 1392 * @return the range of groups associated with the user group 1393 * @throws SystemException if a system exception occurred 1394 */ 1395 public static java.util.List<com.liferay.portal.model.Group> getGroups( 1396 long pk, int start, int end) 1397 throws com.liferay.portal.kernel.exception.SystemException { 1398 return getPersistence().getGroups(pk, start, end); 1399 } 1400 1401 /** 1402 * Returns an ordered range of all the groups associated with the user group. 1403 * 1404 * <p> 1405 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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. 1406 * </p> 1407 * 1408 * @param pk the primary key of the user group 1409 * @param start the lower bound of the range of user groups 1410 * @param end the upper bound of the range of user groups (not inclusive) 1411 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1412 * @return the ordered range of groups associated with the user group 1413 * @throws SystemException if a system exception occurred 1414 */ 1415 public static java.util.List<com.liferay.portal.model.Group> getGroups( 1416 long pk, int start, int end, 1417 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1418 throws com.liferay.portal.kernel.exception.SystemException { 1419 return getPersistence().getGroups(pk, start, end, orderByComparator); 1420 } 1421 1422 /** 1423 * Returns the number of groups associated with the user group. 1424 * 1425 * @param pk the primary key of the user group 1426 * @return the number of groups associated with the user group 1427 * @throws SystemException if a system exception occurred 1428 */ 1429 public static int getGroupsSize(long pk) 1430 throws com.liferay.portal.kernel.exception.SystemException { 1431 return getPersistence().getGroupsSize(pk); 1432 } 1433 1434 /** 1435 * Returns <code>true</code> if the group is associated with the user group. 1436 * 1437 * @param pk the primary key of the user group 1438 * @param groupPK the primary key of the group 1439 * @return <code>true</code> if the group is associated with the user group; <code>false</code> otherwise 1440 * @throws SystemException if a system exception occurred 1441 */ 1442 public static boolean containsGroup(long pk, long groupPK) 1443 throws com.liferay.portal.kernel.exception.SystemException { 1444 return getPersistence().containsGroup(pk, groupPK); 1445 } 1446 1447 /** 1448 * Returns <code>true</code> if the user group has any groups associated with it. 1449 * 1450 * @param pk the primary key of the user group to check for associations with groups 1451 * @return <code>true</code> if the user group has any groups associated with it; <code>false</code> otherwise 1452 * @throws SystemException if a system exception occurred 1453 */ 1454 public static boolean containsGroups(long pk) 1455 throws com.liferay.portal.kernel.exception.SystemException { 1456 return getPersistence().containsGroups(pk); 1457 } 1458 1459 /** 1460 * Adds an association between the user group and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1461 * 1462 * @param pk the primary key of the user group 1463 * @param groupPK the primary key of the group 1464 * @throws SystemException if a system exception occurred 1465 */ 1466 public static void addGroup(long pk, long groupPK) 1467 throws com.liferay.portal.kernel.exception.SystemException { 1468 getPersistence().addGroup(pk, groupPK); 1469 } 1470 1471 /** 1472 * Adds an association between the user group and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1473 * 1474 * @param pk the primary key of the user group 1475 * @param group the group 1476 * @throws SystemException if a system exception occurred 1477 */ 1478 public static void addGroup(long pk, com.liferay.portal.model.Group group) 1479 throws com.liferay.portal.kernel.exception.SystemException { 1480 getPersistence().addGroup(pk, group); 1481 } 1482 1483 /** 1484 * Adds an association between the user group and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1485 * 1486 * @param pk the primary key of the user group 1487 * @param groupPKs the primary keys of the groups 1488 * @throws SystemException if a system exception occurred 1489 */ 1490 public static void addGroups(long pk, long[] groupPKs) 1491 throws com.liferay.portal.kernel.exception.SystemException { 1492 getPersistence().addGroups(pk, groupPKs); 1493 } 1494 1495 /** 1496 * Adds an association between the user group and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1497 * 1498 * @param pk the primary key of the user group 1499 * @param groups the groups 1500 * @throws SystemException if a system exception occurred 1501 */ 1502 public static void addGroups(long pk, 1503 java.util.List<com.liferay.portal.model.Group> groups) 1504 throws com.liferay.portal.kernel.exception.SystemException { 1505 getPersistence().addGroups(pk, groups); 1506 } 1507 1508 /** 1509 * Clears all associations between the user group and its groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1510 * 1511 * @param pk the primary key of the user group to clear the associated groups from 1512 * @throws SystemException if a system exception occurred 1513 */ 1514 public static void clearGroups(long pk) 1515 throws com.liferay.portal.kernel.exception.SystemException { 1516 getPersistence().clearGroups(pk); 1517 } 1518 1519 /** 1520 * Removes the association between the user group and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1521 * 1522 * @param pk the primary key of the user group 1523 * @param groupPK the primary key of the group 1524 * @throws SystemException if a system exception occurred 1525 */ 1526 public static void removeGroup(long pk, long groupPK) 1527 throws com.liferay.portal.kernel.exception.SystemException { 1528 getPersistence().removeGroup(pk, groupPK); 1529 } 1530 1531 /** 1532 * Removes the association between the user group and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1533 * 1534 * @param pk the primary key of the user group 1535 * @param group the group 1536 * @throws SystemException if a system exception occurred 1537 */ 1538 public static void removeGroup(long pk, com.liferay.portal.model.Group group) 1539 throws com.liferay.portal.kernel.exception.SystemException { 1540 getPersistence().removeGroup(pk, group); 1541 } 1542 1543 /** 1544 * Removes the association between the user group and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1545 * 1546 * @param pk the primary key of the user group 1547 * @param groupPKs the primary keys of the groups 1548 * @throws SystemException if a system exception occurred 1549 */ 1550 public static void removeGroups(long pk, long[] groupPKs) 1551 throws com.liferay.portal.kernel.exception.SystemException { 1552 getPersistence().removeGroups(pk, groupPKs); 1553 } 1554 1555 /** 1556 * Removes the association between the user group and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1557 * 1558 * @param pk the primary key of the user group 1559 * @param groups the groups 1560 * @throws SystemException if a system exception occurred 1561 */ 1562 public static void removeGroups(long pk, 1563 java.util.List<com.liferay.portal.model.Group> groups) 1564 throws com.liferay.portal.kernel.exception.SystemException { 1565 getPersistence().removeGroups(pk, groups); 1566 } 1567 1568 /** 1569 * 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. 1570 * 1571 * @param pk the primary key of the user group 1572 * @param groupPKs the primary keys of the groups to be associated with the user group 1573 * @throws SystemException if a system exception occurred 1574 */ 1575 public static void setGroups(long pk, long[] groupPKs) 1576 throws com.liferay.portal.kernel.exception.SystemException { 1577 getPersistence().setGroups(pk, groupPKs); 1578 } 1579 1580 /** 1581 * 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. 1582 * 1583 * @param pk the primary key of the user group 1584 * @param groups the groups to be associated with the user group 1585 * @throws SystemException if a system exception occurred 1586 */ 1587 public static void setGroups(long pk, 1588 java.util.List<com.liferay.portal.model.Group> groups) 1589 throws com.liferay.portal.kernel.exception.SystemException { 1590 getPersistence().setGroups(pk, groups); 1591 } 1592 1593 /** 1594 * Returns all the teams associated with the user group. 1595 * 1596 * @param pk the primary key of the user group 1597 * @return the teams associated with the user group 1598 * @throws SystemException if a system exception occurred 1599 */ 1600 public static java.util.List<com.liferay.portal.model.Team> getTeams( 1601 long pk) throws com.liferay.portal.kernel.exception.SystemException { 1602 return getPersistence().getTeams(pk); 1603 } 1604 1605 /** 1606 * Returns a range of all the teams associated with the user group. 1607 * 1608 * <p> 1609 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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. 1610 * </p> 1611 * 1612 * @param pk the primary key of the user group 1613 * @param start the lower bound of the range of user groups 1614 * @param end the upper bound of the range of user groups (not inclusive) 1615 * @return the range of teams associated with the user group 1616 * @throws SystemException if a system exception occurred 1617 */ 1618 public static java.util.List<com.liferay.portal.model.Team> getTeams( 1619 long pk, int start, int end) 1620 throws com.liferay.portal.kernel.exception.SystemException { 1621 return getPersistence().getTeams(pk, start, end); 1622 } 1623 1624 /** 1625 * Returns an ordered range of all the teams associated with the user group. 1626 * 1627 * <p> 1628 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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. 1629 * </p> 1630 * 1631 * @param pk the primary key of the user group 1632 * @param start the lower bound of the range of user groups 1633 * @param end the upper bound of the range of user groups (not inclusive) 1634 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1635 * @return the ordered range of teams associated with the user group 1636 * @throws SystemException if a system exception occurred 1637 */ 1638 public static java.util.List<com.liferay.portal.model.Team> getTeams( 1639 long pk, int start, int end, 1640 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1641 throws com.liferay.portal.kernel.exception.SystemException { 1642 return getPersistence().getTeams(pk, start, end, orderByComparator); 1643 } 1644 1645 /** 1646 * Returns the number of teams associated with the user group. 1647 * 1648 * @param pk the primary key of the user group 1649 * @return the number of teams associated with the user group 1650 * @throws SystemException if a system exception occurred 1651 */ 1652 public static int getTeamsSize(long pk) 1653 throws com.liferay.portal.kernel.exception.SystemException { 1654 return getPersistence().getTeamsSize(pk); 1655 } 1656 1657 /** 1658 * Returns <code>true</code> if the team is associated with the user group. 1659 * 1660 * @param pk the primary key of the user group 1661 * @param teamPK the primary key of the team 1662 * @return <code>true</code> if the team is associated with the user group; <code>false</code> otherwise 1663 * @throws SystemException if a system exception occurred 1664 */ 1665 public static boolean containsTeam(long pk, long teamPK) 1666 throws com.liferay.portal.kernel.exception.SystemException { 1667 return getPersistence().containsTeam(pk, teamPK); 1668 } 1669 1670 /** 1671 * Returns <code>true</code> if the user group has any teams associated with it. 1672 * 1673 * @param pk the primary key of the user group to check for associations with teams 1674 * @return <code>true</code> if the user group has any teams associated with it; <code>false</code> otherwise 1675 * @throws SystemException if a system exception occurred 1676 */ 1677 public static boolean containsTeams(long pk) 1678 throws com.liferay.portal.kernel.exception.SystemException { 1679 return getPersistence().containsTeams(pk); 1680 } 1681 1682 /** 1683 * Adds an association between the user group and the team. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1684 * 1685 * @param pk the primary key of the user group 1686 * @param teamPK the primary key of the team 1687 * @throws SystemException if a system exception occurred 1688 */ 1689 public static void addTeam(long pk, long teamPK) 1690 throws com.liferay.portal.kernel.exception.SystemException { 1691 getPersistence().addTeam(pk, teamPK); 1692 } 1693 1694 /** 1695 * Adds an association between the user group and the team. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1696 * 1697 * @param pk the primary key of the user group 1698 * @param team the team 1699 * @throws SystemException if a system exception occurred 1700 */ 1701 public static void addTeam(long pk, com.liferay.portal.model.Team team) 1702 throws com.liferay.portal.kernel.exception.SystemException { 1703 getPersistence().addTeam(pk, team); 1704 } 1705 1706 /** 1707 * Adds an association between the user group and the teams. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1708 * 1709 * @param pk the primary key of the user group 1710 * @param teamPKs the primary keys of the teams 1711 * @throws SystemException if a system exception occurred 1712 */ 1713 public static void addTeams(long pk, long[] teamPKs) 1714 throws com.liferay.portal.kernel.exception.SystemException { 1715 getPersistence().addTeams(pk, teamPKs); 1716 } 1717 1718 /** 1719 * Adds an association between the user group and the teams. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1720 * 1721 * @param pk the primary key of the user group 1722 * @param teams the teams 1723 * @throws SystemException if a system exception occurred 1724 */ 1725 public static void addTeams(long pk, 1726 java.util.List<com.liferay.portal.model.Team> teams) 1727 throws com.liferay.portal.kernel.exception.SystemException { 1728 getPersistence().addTeams(pk, teams); 1729 } 1730 1731 /** 1732 * Clears all associations between the user group and its teams. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1733 * 1734 * @param pk the primary key of the user group to clear the associated teams from 1735 * @throws SystemException if a system exception occurred 1736 */ 1737 public static void clearTeams(long pk) 1738 throws com.liferay.portal.kernel.exception.SystemException { 1739 getPersistence().clearTeams(pk); 1740 } 1741 1742 /** 1743 * Removes the association between the user group and the team. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1744 * 1745 * @param pk the primary key of the user group 1746 * @param teamPK the primary key of the team 1747 * @throws SystemException if a system exception occurred 1748 */ 1749 public static void removeTeam(long pk, long teamPK) 1750 throws com.liferay.portal.kernel.exception.SystemException { 1751 getPersistence().removeTeam(pk, teamPK); 1752 } 1753 1754 /** 1755 * Removes the association between the user group and the team. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1756 * 1757 * @param pk the primary key of the user group 1758 * @param team the team 1759 * @throws SystemException if a system exception occurred 1760 */ 1761 public static void removeTeam(long pk, com.liferay.portal.model.Team team) 1762 throws com.liferay.portal.kernel.exception.SystemException { 1763 getPersistence().removeTeam(pk, team); 1764 } 1765 1766 /** 1767 * Removes the association between the user group and the teams. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1768 * 1769 * @param pk the primary key of the user group 1770 * @param teamPKs the primary keys of the teams 1771 * @throws SystemException if a system exception occurred 1772 */ 1773 public static void removeTeams(long pk, long[] teamPKs) 1774 throws com.liferay.portal.kernel.exception.SystemException { 1775 getPersistence().removeTeams(pk, teamPKs); 1776 } 1777 1778 /** 1779 * Removes the association between the user group and the teams. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1780 * 1781 * @param pk the primary key of the user group 1782 * @param teams the teams 1783 * @throws SystemException if a system exception occurred 1784 */ 1785 public static void removeTeams(long pk, 1786 java.util.List<com.liferay.portal.model.Team> teams) 1787 throws com.liferay.portal.kernel.exception.SystemException { 1788 getPersistence().removeTeams(pk, teams); 1789 } 1790 1791 /** 1792 * 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. 1793 * 1794 * @param pk the primary key of the user group 1795 * @param teamPKs the primary keys of the teams to be associated with the user group 1796 * @throws SystemException if a system exception occurred 1797 */ 1798 public static void setTeams(long pk, long[] teamPKs) 1799 throws com.liferay.portal.kernel.exception.SystemException { 1800 getPersistence().setTeams(pk, teamPKs); 1801 } 1802 1803 /** 1804 * 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. 1805 * 1806 * @param pk the primary key of the user group 1807 * @param teams the teams to be associated with the user group 1808 * @throws SystemException if a system exception occurred 1809 */ 1810 public static void setTeams(long pk, 1811 java.util.List<com.liferay.portal.model.Team> teams) 1812 throws com.liferay.portal.kernel.exception.SystemException { 1813 getPersistence().setTeams(pk, teams); 1814 } 1815 1816 /** 1817 * Returns all the users associated with the user group. 1818 * 1819 * @param pk the primary key of the user group 1820 * @return the users associated with the user group 1821 * @throws SystemException if a system exception occurred 1822 */ 1823 public static java.util.List<com.liferay.portal.model.User> getUsers( 1824 long pk) throws com.liferay.portal.kernel.exception.SystemException { 1825 return getPersistence().getUsers(pk); 1826 } 1827 1828 /** 1829 * Returns a range of all the users associated with the user group. 1830 * 1831 * <p> 1832 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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. 1833 * </p> 1834 * 1835 * @param pk the primary key of the user group 1836 * @param start the lower bound of the range of user groups 1837 * @param end the upper bound of the range of user groups (not inclusive) 1838 * @return the range of users associated with the user group 1839 * @throws SystemException if a system exception occurred 1840 */ 1841 public static java.util.List<com.liferay.portal.model.User> getUsers( 1842 long pk, int start, int end) 1843 throws com.liferay.portal.kernel.exception.SystemException { 1844 return getPersistence().getUsers(pk, start, end); 1845 } 1846 1847 /** 1848 * Returns an ordered range of all the users associated with the user group. 1849 * 1850 * <p> 1851 * 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 com.liferay.portal.kernel.dao.orm.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 com.liferay.portal.kernel.dao.orm.QueryUtil#ALL_POS}), then the query will include the default ORDER BY logic from {@link com.liferay.portal.model.impl.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. 1852 * </p> 1853 * 1854 * @param pk the primary key of the user group 1855 * @param start the lower bound of the range of user groups 1856 * @param end the upper bound of the range of user groups (not inclusive) 1857 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1858 * @return the ordered range of users associated with the user group 1859 * @throws SystemException if a system exception occurred 1860 */ 1861 public static java.util.List<com.liferay.portal.model.User> getUsers( 1862 long pk, int start, int end, 1863 com.liferay.portal.kernel.util.OrderByComparator orderByComparator) 1864 throws com.liferay.portal.kernel.exception.SystemException { 1865 return getPersistence().getUsers(pk, start, end, orderByComparator); 1866 } 1867 1868 /** 1869 * Returns the number of users associated with the user group. 1870 * 1871 * @param pk the primary key of the user group 1872 * @return the number of users associated with the user group 1873 * @throws SystemException if a system exception occurred 1874 */ 1875 public static int getUsersSize(long pk) 1876 throws com.liferay.portal.kernel.exception.SystemException { 1877 return getPersistence().getUsersSize(pk); 1878 } 1879 1880 /** 1881 * Returns <code>true</code> if the user is associated with the user group. 1882 * 1883 * @param pk the primary key of the user group 1884 * @param userPK the primary key of the user 1885 * @return <code>true</code> if the user is associated with the user group; <code>false</code> otherwise 1886 * @throws SystemException if a system exception occurred 1887 */ 1888 public static boolean containsUser(long pk, long userPK) 1889 throws com.liferay.portal.kernel.exception.SystemException { 1890 return getPersistence().containsUser(pk, userPK); 1891 } 1892 1893 /** 1894 * Returns <code>true</code> if the user group has any users associated with it. 1895 * 1896 * @param pk the primary key of the user group to check for associations with users 1897 * @return <code>true</code> if the user group has any users associated with it; <code>false</code> otherwise 1898 * @throws SystemException if a system exception occurred 1899 */ 1900 public static boolean containsUsers(long pk) 1901 throws com.liferay.portal.kernel.exception.SystemException { 1902 return getPersistence().containsUsers(pk); 1903 } 1904 1905 /** 1906 * Adds an association between the user group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1907 * 1908 * @param pk the primary key of the user group 1909 * @param userPK the primary key of the user 1910 * @throws SystemException if a system exception occurred 1911 */ 1912 public static void addUser(long pk, long userPK) 1913 throws com.liferay.portal.kernel.exception.SystemException { 1914 getPersistence().addUser(pk, userPK); 1915 } 1916 1917 /** 1918 * Adds an association between the user group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1919 * 1920 * @param pk the primary key of the user group 1921 * @param user the user 1922 * @throws SystemException if a system exception occurred 1923 */ 1924 public static void addUser(long pk, com.liferay.portal.model.User user) 1925 throws com.liferay.portal.kernel.exception.SystemException { 1926 getPersistence().addUser(pk, user); 1927 } 1928 1929 /** 1930 * Adds an association between the user group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1931 * 1932 * @param pk the primary key of the user group 1933 * @param userPKs the primary keys of the users 1934 * @throws SystemException if a system exception occurred 1935 */ 1936 public static void addUsers(long pk, long[] userPKs) 1937 throws com.liferay.portal.kernel.exception.SystemException { 1938 getPersistence().addUsers(pk, userPKs); 1939 } 1940 1941 /** 1942 * Adds an association between the user group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1943 * 1944 * @param pk the primary key of the user group 1945 * @param users the users 1946 * @throws SystemException if a system exception occurred 1947 */ 1948 public static void addUsers(long pk, 1949 java.util.List<com.liferay.portal.model.User> users) 1950 throws com.liferay.portal.kernel.exception.SystemException { 1951 getPersistence().addUsers(pk, users); 1952 } 1953 1954 /** 1955 * Clears all associations between the user group and its users. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1956 * 1957 * @param pk the primary key of the user group to clear the associated users from 1958 * @throws SystemException if a system exception occurred 1959 */ 1960 public static void clearUsers(long pk) 1961 throws com.liferay.portal.kernel.exception.SystemException { 1962 getPersistence().clearUsers(pk); 1963 } 1964 1965 /** 1966 * Removes the association between the user group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1967 * 1968 * @param pk the primary key of the user group 1969 * @param userPK the primary key of the user 1970 * @throws SystemException if a system exception occurred 1971 */ 1972 public static void removeUser(long pk, long userPK) 1973 throws com.liferay.portal.kernel.exception.SystemException { 1974 getPersistence().removeUser(pk, userPK); 1975 } 1976 1977 /** 1978 * Removes the association between the user group and the user. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1979 * 1980 * @param pk the primary key of the user group 1981 * @param user the user 1982 * @throws SystemException if a system exception occurred 1983 */ 1984 public static void removeUser(long pk, com.liferay.portal.model.User user) 1985 throws com.liferay.portal.kernel.exception.SystemException { 1986 getPersistence().removeUser(pk, user); 1987 } 1988 1989 /** 1990 * Removes the association between the user group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache. 1991 * 1992 * @param pk the primary key of the user group 1993 * @param userPKs the primary keys of the users 1994 * @throws SystemException if a system exception occurred 1995 */ 1996 public static void removeUsers(long pk, long[] userPKs) 1997 throws com.liferay.portal.kernel.exception.SystemException { 1998 getPersistence().removeUsers(pk, userPKs); 1999 } 2000 2001 /** 2002 * Removes the association between the user group and the users. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2003 * 2004 * @param pk the primary key of the user group 2005 * @param users the users 2006 * @throws SystemException if a system exception occurred 2007 */ 2008 public static void removeUsers(long pk, 2009 java.util.List<com.liferay.portal.model.User> users) 2010 throws com.liferay.portal.kernel.exception.SystemException { 2011 getPersistence().removeUsers(pk, users); 2012 } 2013 2014 /** 2015 * 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. 2016 * 2017 * @param pk the primary key of the user group 2018 * @param userPKs the primary keys of the users to be associated with the user group 2019 * @throws SystemException if a system exception occurred 2020 */ 2021 public static void setUsers(long pk, long[] userPKs) 2022 throws com.liferay.portal.kernel.exception.SystemException { 2023 getPersistence().setUsers(pk, userPKs); 2024 } 2025 2026 /** 2027 * 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. 2028 * 2029 * @param pk the primary key of the user group 2030 * @param users the users to be associated with the user group 2031 * @throws SystemException if a system exception occurred 2032 */ 2033 public static void setUsers(long pk, 2034 java.util.List<com.liferay.portal.model.User> users) 2035 throws com.liferay.portal.kernel.exception.SystemException { 2036 getPersistence().setUsers(pk, users); 2037 } 2038 2039 public static UserGroupPersistence getPersistence() { 2040 if (_persistence == null) { 2041 _persistence = (UserGroupPersistence)PortalBeanLocatorUtil.locate(UserGroupPersistence.class.getName()); 2042 2043 ReferenceRegistry.registerReference(UserGroupUtil.class, 2044 "_persistence"); 2045 } 2046 2047 return _persistence; 2048 } 2049 2050 /** 2051 * @deprecated As of 6.2.0 2052 */ 2053 public void setPersistence(UserGroupPersistence persistence) { 2054 } 2055 2056 private static UserGroupPersistence _persistence; 2057 }