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