001 /** 002 * Copyright (c) 2000-present Liferay, Inc. All rights reserved. 003 * 004 * This library is free software; you can redistribute it and/or modify it under 005 * the terms of the GNU Lesser General Public License as published by the Free 006 * Software Foundation; either version 2.1 of the License, or (at your option) 007 * any later version. 008 * 009 * This library is distributed in the hope that it will be useful, but WITHOUT 010 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS 011 * FOR A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more 012 * details. 013 */ 014 015 package com.liferay.portal.service.persistence; 016 017 import aQute.bnd.annotation.ProviderType; 018 019 import com.liferay.portal.kernel.bean.PortalBeanLocatorUtil; 020 import com.liferay.portal.kernel.dao.orm.DynamicQuery; 021 import com.liferay.portal.kernel.util.OrderByComparator; 022 import com.liferay.portal.kernel.util.ReferenceRegistry; 023 import com.liferay.portal.model.User; 024 import com.liferay.portal.service.ServiceContext; 025 026 import java.util.Date; 027 import java.util.List; 028 029 /** 030 * The persistence utility for the user service. This utility wraps {@link com.liferay.portal.service.persistence.impl.UserPersistenceImpl} 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. 031 * 032 * <p> 033 * Caching information and settings can be found in <code>portal.properties</code> 034 * </p> 035 * 036 * @author Brian Wing Shun Chan 037 * @see UserPersistence 038 * @see com.liferay.portal.service.persistence.impl.UserPersistenceImpl 039 * @generated 040 */ 041 @ProviderType 042 public class UserUtil { 043 /* 044 * NOTE FOR DEVELOPERS: 045 * 046 * Never modify this class directly. Modify <code>service.xml</code> and rerun ServiceBuilder to regenerate this class. 047 */ 048 049 /** 050 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache() 051 */ 052 public static void clearCache() { 053 getPersistence().clearCache(); 054 } 055 056 /** 057 * @see com.liferay.portal.service.persistence.BasePersistence#clearCache(com.liferay.portal.model.BaseModel) 058 */ 059 public static void clearCache(User user) { 060 getPersistence().clearCache(user); 061 } 062 063 /** 064 * @see com.liferay.portal.service.persistence.BasePersistence#countWithDynamicQuery(DynamicQuery) 065 */ 066 public static long countWithDynamicQuery(DynamicQuery dynamicQuery) { 067 return getPersistence().countWithDynamicQuery(dynamicQuery); 068 } 069 070 /** 071 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery) 072 */ 073 public static List<User> findWithDynamicQuery(DynamicQuery dynamicQuery) { 074 return getPersistence().findWithDynamicQuery(dynamicQuery); 075 } 076 077 /** 078 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int) 079 */ 080 public static List<User> findWithDynamicQuery(DynamicQuery dynamicQuery, 081 int start, int end) { 082 return getPersistence().findWithDynamicQuery(dynamicQuery, start, end); 083 } 084 085 /** 086 * @see com.liferay.portal.service.persistence.BasePersistence#findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator) 087 */ 088 public static List<User> findWithDynamicQuery(DynamicQuery dynamicQuery, 089 int start, int end, OrderByComparator<User> orderByComparator) { 090 return getPersistence() 091 .findWithDynamicQuery(dynamicQuery, start, end, 092 orderByComparator); 093 } 094 095 /** 096 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel) 097 */ 098 public static User update(User user) { 099 return getPersistence().update(user); 100 } 101 102 /** 103 * @see com.liferay.portal.service.persistence.BasePersistence#update(com.liferay.portal.model.BaseModel, ServiceContext) 104 */ 105 public static User update(User user, ServiceContext serviceContext) { 106 return getPersistence().update(user, serviceContext); 107 } 108 109 /** 110 * Returns all the users where uuid = ?. 111 * 112 * @param uuid the uuid 113 * @return the matching users 114 */ 115 public static List<User> findByUuid(java.lang.String uuid) { 116 return getPersistence().findByUuid(uuid); 117 } 118 119 /** 120 * Returns a range of all the users where uuid = ?. 121 * 122 * <p> 123 * 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 UserModelImpl}. 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. 124 * </p> 125 * 126 * @param uuid the uuid 127 * @param start the lower bound of the range of users 128 * @param end the upper bound of the range of users (not inclusive) 129 * @return the range of matching users 130 */ 131 public static List<User> findByUuid(java.lang.String uuid, int start, 132 int end) { 133 return getPersistence().findByUuid(uuid, start, end); 134 } 135 136 /** 137 * Returns an ordered range of all the users where uuid = ?. 138 * 139 * <p> 140 * 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 UserModelImpl}. 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. 141 * </p> 142 * 143 * @param uuid the uuid 144 * @param start the lower bound of the range of users 145 * @param end the upper bound of the range of users (not inclusive) 146 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 147 * @return the ordered range of matching users 148 */ 149 public static List<User> findByUuid(java.lang.String uuid, int start, 150 int end, OrderByComparator<User> orderByComparator) { 151 return getPersistence().findByUuid(uuid, start, end, orderByComparator); 152 } 153 154 /** 155 * Returns an ordered range of all the users where uuid = ?. 156 * 157 * <p> 158 * 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 UserModelImpl}. 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. 159 * </p> 160 * 161 * @param uuid the uuid 162 * @param start the lower bound of the range of users 163 * @param end the upper bound of the range of users (not inclusive) 164 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 165 * @param retrieveFromCache whether to retrieve from the finder cache 166 * @return the ordered range of matching users 167 */ 168 public static List<User> findByUuid(java.lang.String uuid, int start, 169 int end, OrderByComparator<User> orderByComparator, 170 boolean retrieveFromCache) { 171 return getPersistence() 172 .findByUuid(uuid, start, end, orderByComparator, 173 retrieveFromCache); 174 } 175 176 /** 177 * Returns the first user in the ordered set where uuid = ?. 178 * 179 * @param uuid the uuid 180 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 181 * @return the first matching user 182 * @throws NoSuchUserException if a matching user could not be found 183 */ 184 public static User findByUuid_First(java.lang.String uuid, 185 OrderByComparator<User> orderByComparator) 186 throws com.liferay.portal.exception.NoSuchUserException { 187 return getPersistence().findByUuid_First(uuid, orderByComparator); 188 } 189 190 /** 191 * Returns the first user in the ordered set where uuid = ?. 192 * 193 * @param uuid the uuid 194 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 195 * @return the first matching user, or <code>null</code> if a matching user could not be found 196 */ 197 public static User fetchByUuid_First(java.lang.String uuid, 198 OrderByComparator<User> orderByComparator) { 199 return getPersistence().fetchByUuid_First(uuid, orderByComparator); 200 } 201 202 /** 203 * Returns the last user in the ordered set where uuid = ?. 204 * 205 * @param uuid the uuid 206 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 207 * @return the last matching user 208 * @throws NoSuchUserException if a matching user could not be found 209 */ 210 public static User findByUuid_Last(java.lang.String uuid, 211 OrderByComparator<User> orderByComparator) 212 throws com.liferay.portal.exception.NoSuchUserException { 213 return getPersistence().findByUuid_Last(uuid, orderByComparator); 214 } 215 216 /** 217 * Returns the last user in the ordered set where uuid = ?. 218 * 219 * @param uuid the uuid 220 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 221 * @return the last matching user, or <code>null</code> if a matching user could not be found 222 */ 223 public static User fetchByUuid_Last(java.lang.String uuid, 224 OrderByComparator<User> orderByComparator) { 225 return getPersistence().fetchByUuid_Last(uuid, orderByComparator); 226 } 227 228 /** 229 * Returns the users before and after the current user in the ordered set where uuid = ?. 230 * 231 * @param userId the primary key of the current user 232 * @param uuid the uuid 233 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 234 * @return the previous, current, and next user 235 * @throws NoSuchUserException if a user with the primary key could not be found 236 */ 237 public static User[] findByUuid_PrevAndNext(long userId, 238 java.lang.String uuid, OrderByComparator<User> orderByComparator) 239 throws com.liferay.portal.exception.NoSuchUserException { 240 return getPersistence() 241 .findByUuid_PrevAndNext(userId, uuid, orderByComparator); 242 } 243 244 /** 245 * Removes all the users where uuid = ? from the database. 246 * 247 * @param uuid the uuid 248 */ 249 public static void removeByUuid(java.lang.String uuid) { 250 getPersistence().removeByUuid(uuid); 251 } 252 253 /** 254 * Returns the number of users where uuid = ?. 255 * 256 * @param uuid the uuid 257 * @return the number of matching users 258 */ 259 public static int countByUuid(java.lang.String uuid) { 260 return getPersistence().countByUuid(uuid); 261 } 262 263 /** 264 * Returns all the users where uuid = ? and companyId = ?. 265 * 266 * @param uuid the uuid 267 * @param companyId the company ID 268 * @return the matching users 269 */ 270 public static List<User> findByUuid_C(java.lang.String uuid, long companyId) { 271 return getPersistence().findByUuid_C(uuid, companyId); 272 } 273 274 /** 275 * Returns a range of all the users where uuid = ? and companyId = ?. 276 * 277 * <p> 278 * 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 UserModelImpl}. 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. 279 * </p> 280 * 281 * @param uuid the uuid 282 * @param companyId the company ID 283 * @param start the lower bound of the range of users 284 * @param end the upper bound of the range of users (not inclusive) 285 * @return the range of matching users 286 */ 287 public static List<User> findByUuid_C(java.lang.String uuid, 288 long companyId, int start, int end) { 289 return getPersistence().findByUuid_C(uuid, companyId, start, end); 290 } 291 292 /** 293 * Returns an ordered range of all the users where uuid = ? and companyId = ?. 294 * 295 * <p> 296 * 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 UserModelImpl}. 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. 297 * </p> 298 * 299 * @param uuid the uuid 300 * @param companyId the company ID 301 * @param start the lower bound of the range of users 302 * @param end the upper bound of the range of users (not inclusive) 303 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 304 * @return the ordered range of matching users 305 */ 306 public static List<User> findByUuid_C(java.lang.String uuid, 307 long companyId, int start, int end, 308 OrderByComparator<User> orderByComparator) { 309 return getPersistence() 310 .findByUuid_C(uuid, companyId, start, end, orderByComparator); 311 } 312 313 /** 314 * Returns an ordered range of all the users where uuid = ? and companyId = ?. 315 * 316 * <p> 317 * 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 UserModelImpl}. 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. 318 * </p> 319 * 320 * @param uuid the uuid 321 * @param companyId the company ID 322 * @param start the lower bound of the range of users 323 * @param end the upper bound of the range of users (not inclusive) 324 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 325 * @param retrieveFromCache whether to retrieve from the finder cache 326 * @return the ordered range of matching users 327 */ 328 public static List<User> findByUuid_C(java.lang.String uuid, 329 long companyId, int start, int end, 330 OrderByComparator<User> orderByComparator, boolean retrieveFromCache) { 331 return getPersistence() 332 .findByUuid_C(uuid, companyId, start, end, 333 orderByComparator, retrieveFromCache); 334 } 335 336 /** 337 * Returns the first user in the ordered set where uuid = ? and companyId = ?. 338 * 339 * @param uuid the uuid 340 * @param companyId the company ID 341 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 342 * @return the first matching user 343 * @throws NoSuchUserException if a matching user could not be found 344 */ 345 public static User findByUuid_C_First(java.lang.String uuid, 346 long companyId, OrderByComparator<User> orderByComparator) 347 throws com.liferay.portal.exception.NoSuchUserException { 348 return getPersistence() 349 .findByUuid_C_First(uuid, companyId, orderByComparator); 350 } 351 352 /** 353 * Returns the first user in the ordered set where uuid = ? and companyId = ?. 354 * 355 * @param uuid the uuid 356 * @param companyId the company ID 357 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 358 * @return the first matching user, or <code>null</code> if a matching user could not be found 359 */ 360 public static User fetchByUuid_C_First(java.lang.String uuid, 361 long companyId, OrderByComparator<User> orderByComparator) { 362 return getPersistence() 363 .fetchByUuid_C_First(uuid, companyId, orderByComparator); 364 } 365 366 /** 367 * Returns the last user in the ordered set where uuid = ? and companyId = ?. 368 * 369 * @param uuid the uuid 370 * @param companyId the company ID 371 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 372 * @return the last matching user 373 * @throws NoSuchUserException if a matching user could not be found 374 */ 375 public static User findByUuid_C_Last(java.lang.String uuid, long companyId, 376 OrderByComparator<User> orderByComparator) 377 throws com.liferay.portal.exception.NoSuchUserException { 378 return getPersistence() 379 .findByUuid_C_Last(uuid, companyId, orderByComparator); 380 } 381 382 /** 383 * Returns the last user in the ordered set where uuid = ? and companyId = ?. 384 * 385 * @param uuid the uuid 386 * @param companyId the company ID 387 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 388 * @return the last matching user, or <code>null</code> if a matching user could not be found 389 */ 390 public static User fetchByUuid_C_Last(java.lang.String uuid, 391 long companyId, OrderByComparator<User> orderByComparator) { 392 return getPersistence() 393 .fetchByUuid_C_Last(uuid, companyId, orderByComparator); 394 } 395 396 /** 397 * Returns the users before and after the current user in the ordered set where uuid = ? and companyId = ?. 398 * 399 * @param userId the primary key of the current user 400 * @param uuid the uuid 401 * @param companyId the company ID 402 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 403 * @return the previous, current, and next user 404 * @throws NoSuchUserException if a user with the primary key could not be found 405 */ 406 public static User[] findByUuid_C_PrevAndNext(long userId, 407 java.lang.String uuid, long companyId, 408 OrderByComparator<User> orderByComparator) 409 throws com.liferay.portal.exception.NoSuchUserException { 410 return getPersistence() 411 .findByUuid_C_PrevAndNext(userId, uuid, companyId, 412 orderByComparator); 413 } 414 415 /** 416 * Removes all the users where uuid = ? and companyId = ? from the database. 417 * 418 * @param uuid the uuid 419 * @param companyId the company ID 420 */ 421 public static void removeByUuid_C(java.lang.String uuid, long companyId) { 422 getPersistence().removeByUuid_C(uuid, companyId); 423 } 424 425 /** 426 * Returns the number of users where uuid = ? and companyId = ?. 427 * 428 * @param uuid the uuid 429 * @param companyId the company ID 430 * @return the number of matching users 431 */ 432 public static int countByUuid_C(java.lang.String uuid, long companyId) { 433 return getPersistence().countByUuid_C(uuid, companyId); 434 } 435 436 /** 437 * Returns all the users where companyId = ?. 438 * 439 * @param companyId the company ID 440 * @return the matching users 441 */ 442 public static List<User> findByCompanyId(long companyId) { 443 return getPersistence().findByCompanyId(companyId); 444 } 445 446 /** 447 * Returns a range of all the users where companyId = ?. 448 * 449 * <p> 450 * 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 UserModelImpl}. 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. 451 * </p> 452 * 453 * @param companyId the company ID 454 * @param start the lower bound of the range of users 455 * @param end the upper bound of the range of users (not inclusive) 456 * @return the range of matching users 457 */ 458 public static List<User> findByCompanyId(long companyId, int start, int end) { 459 return getPersistence().findByCompanyId(companyId, start, end); 460 } 461 462 /** 463 * Returns an ordered range of all the users where companyId = ?. 464 * 465 * <p> 466 * 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 UserModelImpl}. 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. 467 * </p> 468 * 469 * @param companyId the company ID 470 * @param start the lower bound of the range of users 471 * @param end the upper bound of the range of users (not inclusive) 472 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 473 * @return the ordered range of matching users 474 */ 475 public static List<User> findByCompanyId(long companyId, int start, 476 int end, OrderByComparator<User> orderByComparator) { 477 return getPersistence() 478 .findByCompanyId(companyId, start, end, orderByComparator); 479 } 480 481 /** 482 * Returns an ordered range of all the users where companyId = ?. 483 * 484 * <p> 485 * 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 UserModelImpl}. 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. 486 * </p> 487 * 488 * @param companyId the company ID 489 * @param start the lower bound of the range of users 490 * @param end the upper bound of the range of users (not inclusive) 491 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 492 * @param retrieveFromCache whether to retrieve from the finder cache 493 * @return the ordered range of matching users 494 */ 495 public static List<User> findByCompanyId(long companyId, int start, 496 int end, OrderByComparator<User> orderByComparator, 497 boolean retrieveFromCache) { 498 return getPersistence() 499 .findByCompanyId(companyId, start, end, orderByComparator, 500 retrieveFromCache); 501 } 502 503 /** 504 * Returns the first user in the ordered set where companyId = ?. 505 * 506 * @param companyId the company ID 507 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 508 * @return the first matching user 509 * @throws NoSuchUserException if a matching user could not be found 510 */ 511 public static User findByCompanyId_First(long companyId, 512 OrderByComparator<User> orderByComparator) 513 throws com.liferay.portal.exception.NoSuchUserException { 514 return getPersistence() 515 .findByCompanyId_First(companyId, orderByComparator); 516 } 517 518 /** 519 * Returns the first user in the ordered set where companyId = ?. 520 * 521 * @param companyId the company ID 522 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 523 * @return the first matching user, or <code>null</code> if a matching user could not be found 524 */ 525 public static User fetchByCompanyId_First(long companyId, 526 OrderByComparator<User> orderByComparator) { 527 return getPersistence() 528 .fetchByCompanyId_First(companyId, orderByComparator); 529 } 530 531 /** 532 * Returns the last user in the ordered set where companyId = ?. 533 * 534 * @param companyId the company ID 535 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 536 * @return the last matching user 537 * @throws NoSuchUserException if a matching user could not be found 538 */ 539 public static User findByCompanyId_Last(long companyId, 540 OrderByComparator<User> orderByComparator) 541 throws com.liferay.portal.exception.NoSuchUserException { 542 return getPersistence() 543 .findByCompanyId_Last(companyId, orderByComparator); 544 } 545 546 /** 547 * Returns the last user in the ordered set where companyId = ?. 548 * 549 * @param companyId the company ID 550 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 551 * @return the last matching user, or <code>null</code> if a matching user could not be found 552 */ 553 public static User fetchByCompanyId_Last(long companyId, 554 OrderByComparator<User> orderByComparator) { 555 return getPersistence() 556 .fetchByCompanyId_Last(companyId, orderByComparator); 557 } 558 559 /** 560 * Returns the users before and after the current user in the ordered set where companyId = ?. 561 * 562 * @param userId the primary key of the current user 563 * @param companyId the company ID 564 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 565 * @return the previous, current, and next user 566 * @throws NoSuchUserException if a user with the primary key could not be found 567 */ 568 public static User[] findByCompanyId_PrevAndNext(long userId, 569 long companyId, OrderByComparator<User> orderByComparator) 570 throws com.liferay.portal.exception.NoSuchUserException { 571 return getPersistence() 572 .findByCompanyId_PrevAndNext(userId, companyId, 573 orderByComparator); 574 } 575 576 /** 577 * Removes all the users where companyId = ? from the database. 578 * 579 * @param companyId the company ID 580 */ 581 public static void removeByCompanyId(long companyId) { 582 getPersistence().removeByCompanyId(companyId); 583 } 584 585 /** 586 * Returns the number of users where companyId = ?. 587 * 588 * @param companyId the company ID 589 * @return the number of matching users 590 */ 591 public static int countByCompanyId(long companyId) { 592 return getPersistence().countByCompanyId(companyId); 593 } 594 595 /** 596 * Returns the user where contactId = ? or throws a {@link NoSuchUserException} if it could not be found. 597 * 598 * @param contactId the contact ID 599 * @return the matching user 600 * @throws NoSuchUserException if a matching user could not be found 601 */ 602 public static User findByContactId(long contactId) 603 throws com.liferay.portal.exception.NoSuchUserException { 604 return getPersistence().findByContactId(contactId); 605 } 606 607 /** 608 * Returns the user where contactId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 609 * 610 * @param contactId the contact ID 611 * @return the matching user, or <code>null</code> if a matching user could not be found 612 */ 613 public static User fetchByContactId(long contactId) { 614 return getPersistence().fetchByContactId(contactId); 615 } 616 617 /** 618 * Returns the user where contactId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 619 * 620 * @param contactId the contact ID 621 * @param retrieveFromCache whether to retrieve from the finder cache 622 * @return the matching user, or <code>null</code> if a matching user could not be found 623 */ 624 public static User fetchByContactId(long contactId, 625 boolean retrieveFromCache) { 626 return getPersistence().fetchByContactId(contactId, retrieveFromCache); 627 } 628 629 /** 630 * Removes the user where contactId = ? from the database. 631 * 632 * @param contactId the contact ID 633 * @return the user that was removed 634 */ 635 public static User removeByContactId(long contactId) 636 throws com.liferay.portal.exception.NoSuchUserException { 637 return getPersistence().removeByContactId(contactId); 638 } 639 640 /** 641 * Returns the number of users where contactId = ?. 642 * 643 * @param contactId the contact ID 644 * @return the number of matching users 645 */ 646 public static int countByContactId(long contactId) { 647 return getPersistence().countByContactId(contactId); 648 } 649 650 /** 651 * Returns all the users where emailAddress = ?. 652 * 653 * @param emailAddress the email address 654 * @return the matching users 655 */ 656 public static List<User> findByEmailAddress(java.lang.String emailAddress) { 657 return getPersistence().findByEmailAddress(emailAddress); 658 } 659 660 /** 661 * Returns a range of all the users where emailAddress = ?. 662 * 663 * <p> 664 * 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 UserModelImpl}. 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. 665 * </p> 666 * 667 * @param emailAddress the email address 668 * @param start the lower bound of the range of users 669 * @param end the upper bound of the range of users (not inclusive) 670 * @return the range of matching users 671 */ 672 public static List<User> findByEmailAddress(java.lang.String emailAddress, 673 int start, int end) { 674 return getPersistence().findByEmailAddress(emailAddress, start, end); 675 } 676 677 /** 678 * Returns an ordered range of all the users where emailAddress = ?. 679 * 680 * <p> 681 * 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 UserModelImpl}. 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. 682 * </p> 683 * 684 * @param emailAddress the email address 685 * @param start the lower bound of the range of users 686 * @param end the upper bound of the range of users (not inclusive) 687 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 688 * @return the ordered range of matching users 689 */ 690 public static List<User> findByEmailAddress(java.lang.String emailAddress, 691 int start, int end, OrderByComparator<User> orderByComparator) { 692 return getPersistence() 693 .findByEmailAddress(emailAddress, start, end, 694 orderByComparator); 695 } 696 697 /** 698 * Returns an ordered range of all the users where emailAddress = ?. 699 * 700 * <p> 701 * 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 UserModelImpl}. 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. 702 * </p> 703 * 704 * @param emailAddress the email address 705 * @param start the lower bound of the range of users 706 * @param end the upper bound of the range of users (not inclusive) 707 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 708 * @param retrieveFromCache whether to retrieve from the finder cache 709 * @return the ordered range of matching users 710 */ 711 public static List<User> findByEmailAddress(java.lang.String emailAddress, 712 int start, int end, OrderByComparator<User> orderByComparator, 713 boolean retrieveFromCache) { 714 return getPersistence() 715 .findByEmailAddress(emailAddress, start, end, 716 orderByComparator, retrieveFromCache); 717 } 718 719 /** 720 * Returns the first user in the ordered set where emailAddress = ?. 721 * 722 * @param emailAddress the email address 723 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 724 * @return the first matching user 725 * @throws NoSuchUserException if a matching user could not be found 726 */ 727 public static User findByEmailAddress_First(java.lang.String emailAddress, 728 OrderByComparator<User> orderByComparator) 729 throws com.liferay.portal.exception.NoSuchUserException { 730 return getPersistence() 731 .findByEmailAddress_First(emailAddress, orderByComparator); 732 } 733 734 /** 735 * Returns the first user in the ordered set where emailAddress = ?. 736 * 737 * @param emailAddress the email address 738 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 739 * @return the first matching user, or <code>null</code> if a matching user could not be found 740 */ 741 public static User fetchByEmailAddress_First( 742 java.lang.String emailAddress, OrderByComparator<User> orderByComparator) { 743 return getPersistence() 744 .fetchByEmailAddress_First(emailAddress, orderByComparator); 745 } 746 747 /** 748 * Returns the last user in the ordered set where emailAddress = ?. 749 * 750 * @param emailAddress the email address 751 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 752 * @return the last matching user 753 * @throws NoSuchUserException if a matching user could not be found 754 */ 755 public static User findByEmailAddress_Last(java.lang.String emailAddress, 756 OrderByComparator<User> orderByComparator) 757 throws com.liferay.portal.exception.NoSuchUserException { 758 return getPersistence() 759 .findByEmailAddress_Last(emailAddress, orderByComparator); 760 } 761 762 /** 763 * Returns the last user in the ordered set where emailAddress = ?. 764 * 765 * @param emailAddress the email address 766 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 767 * @return the last matching user, or <code>null</code> if a matching user could not be found 768 */ 769 public static User fetchByEmailAddress_Last(java.lang.String emailAddress, 770 OrderByComparator<User> orderByComparator) { 771 return getPersistence() 772 .fetchByEmailAddress_Last(emailAddress, orderByComparator); 773 } 774 775 /** 776 * Returns the users before and after the current user in the ordered set where emailAddress = ?. 777 * 778 * @param userId the primary key of the current user 779 * @param emailAddress the email address 780 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 781 * @return the previous, current, and next user 782 * @throws NoSuchUserException if a user with the primary key could not be found 783 */ 784 public static User[] findByEmailAddress_PrevAndNext(long userId, 785 java.lang.String emailAddress, OrderByComparator<User> orderByComparator) 786 throws com.liferay.portal.exception.NoSuchUserException { 787 return getPersistence() 788 .findByEmailAddress_PrevAndNext(userId, emailAddress, 789 orderByComparator); 790 } 791 792 /** 793 * Removes all the users where emailAddress = ? from the database. 794 * 795 * @param emailAddress the email address 796 */ 797 public static void removeByEmailAddress(java.lang.String emailAddress) { 798 getPersistence().removeByEmailAddress(emailAddress); 799 } 800 801 /** 802 * Returns the number of users where emailAddress = ?. 803 * 804 * @param emailAddress the email address 805 * @return the number of matching users 806 */ 807 public static int countByEmailAddress(java.lang.String emailAddress) { 808 return getPersistence().countByEmailAddress(emailAddress); 809 } 810 811 /** 812 * Returns the user where portraitId = ? or throws a {@link NoSuchUserException} if it could not be found. 813 * 814 * @param portraitId the portrait ID 815 * @return the matching user 816 * @throws NoSuchUserException if a matching user could not be found 817 */ 818 public static User findByPortraitId(long portraitId) 819 throws com.liferay.portal.exception.NoSuchUserException { 820 return getPersistence().findByPortraitId(portraitId); 821 } 822 823 /** 824 * Returns the user where portraitId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 825 * 826 * @param portraitId the portrait ID 827 * @return the matching user, or <code>null</code> if a matching user could not be found 828 */ 829 public static User fetchByPortraitId(long portraitId) { 830 return getPersistence().fetchByPortraitId(portraitId); 831 } 832 833 /** 834 * Returns the user where portraitId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 835 * 836 * @param portraitId the portrait ID 837 * @param retrieveFromCache whether to retrieve from the finder cache 838 * @return the matching user, or <code>null</code> if a matching user could not be found 839 */ 840 public static User fetchByPortraitId(long portraitId, 841 boolean retrieveFromCache) { 842 return getPersistence().fetchByPortraitId(portraitId, retrieveFromCache); 843 } 844 845 /** 846 * Removes the user where portraitId = ? from the database. 847 * 848 * @param portraitId the portrait ID 849 * @return the user that was removed 850 */ 851 public static User removeByPortraitId(long portraitId) 852 throws com.liferay.portal.exception.NoSuchUserException { 853 return getPersistence().removeByPortraitId(portraitId); 854 } 855 856 /** 857 * Returns the number of users where portraitId = ?. 858 * 859 * @param portraitId the portrait ID 860 * @return the number of matching users 861 */ 862 public static int countByPortraitId(long portraitId) { 863 return getPersistence().countByPortraitId(portraitId); 864 } 865 866 /** 867 * Returns the user where companyId = ? and userId = ? or throws a {@link NoSuchUserException} if it could not be found. 868 * 869 * @param companyId the company ID 870 * @param userId the user ID 871 * @return the matching user 872 * @throws NoSuchUserException if a matching user could not be found 873 */ 874 public static User findByC_U(long companyId, long userId) 875 throws com.liferay.portal.exception.NoSuchUserException { 876 return getPersistence().findByC_U(companyId, userId); 877 } 878 879 /** 880 * Returns the user where companyId = ? and userId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 881 * 882 * @param companyId the company ID 883 * @param userId the user ID 884 * @return the matching user, or <code>null</code> if a matching user could not be found 885 */ 886 public static User fetchByC_U(long companyId, long userId) { 887 return getPersistence().fetchByC_U(companyId, userId); 888 } 889 890 /** 891 * Returns the user where companyId = ? and userId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 892 * 893 * @param companyId the company ID 894 * @param userId the user ID 895 * @param retrieveFromCache whether to retrieve from the finder cache 896 * @return the matching user, or <code>null</code> if a matching user could not be found 897 */ 898 public static User fetchByC_U(long companyId, long userId, 899 boolean retrieveFromCache) { 900 return getPersistence().fetchByC_U(companyId, userId, retrieveFromCache); 901 } 902 903 /** 904 * Removes the user where companyId = ? and userId = ? from the database. 905 * 906 * @param companyId the company ID 907 * @param userId the user ID 908 * @return the user that was removed 909 */ 910 public static User removeByC_U(long companyId, long userId) 911 throws com.liferay.portal.exception.NoSuchUserException { 912 return getPersistence().removeByC_U(companyId, userId); 913 } 914 915 /** 916 * Returns the number of users where companyId = ? and userId = ?. 917 * 918 * @param companyId the company ID 919 * @param userId the user ID 920 * @return the number of matching users 921 */ 922 public static int countByC_U(long companyId, long userId) { 923 return getPersistence().countByC_U(companyId, userId); 924 } 925 926 /** 927 * Returns all the users where companyId = ? and createDate = ?. 928 * 929 * @param companyId the company ID 930 * @param createDate the create date 931 * @return the matching users 932 */ 933 public static List<User> findByC_CD(long companyId, Date createDate) { 934 return getPersistence().findByC_CD(companyId, createDate); 935 } 936 937 /** 938 * Returns a range of all the users where companyId = ? and createDate = ?. 939 * 940 * <p> 941 * 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 UserModelImpl}. 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. 942 * </p> 943 * 944 * @param companyId the company ID 945 * @param createDate the create date 946 * @param start the lower bound of the range of users 947 * @param end the upper bound of the range of users (not inclusive) 948 * @return the range of matching users 949 */ 950 public static List<User> findByC_CD(long companyId, Date createDate, 951 int start, int end) { 952 return getPersistence().findByC_CD(companyId, createDate, start, end); 953 } 954 955 /** 956 * Returns an ordered range of all the users where companyId = ? and createDate = ?. 957 * 958 * <p> 959 * 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 UserModelImpl}. 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. 960 * </p> 961 * 962 * @param companyId the company ID 963 * @param createDate the create date 964 * @param start the lower bound of the range of users 965 * @param end the upper bound of the range of users (not inclusive) 966 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 967 * @return the ordered range of matching users 968 */ 969 public static List<User> findByC_CD(long companyId, Date createDate, 970 int start, int end, OrderByComparator<User> orderByComparator) { 971 return getPersistence() 972 .findByC_CD(companyId, createDate, start, end, 973 orderByComparator); 974 } 975 976 /** 977 * Returns an ordered range of all the users where companyId = ? and createDate = ?. 978 * 979 * <p> 980 * 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 UserModelImpl}. 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. 981 * </p> 982 * 983 * @param companyId the company ID 984 * @param createDate the create date 985 * @param start the lower bound of the range of users 986 * @param end the upper bound of the range of users (not inclusive) 987 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 988 * @param retrieveFromCache whether to retrieve from the finder cache 989 * @return the ordered range of matching users 990 */ 991 public static List<User> findByC_CD(long companyId, Date createDate, 992 int start, int end, OrderByComparator<User> orderByComparator, 993 boolean retrieveFromCache) { 994 return getPersistence() 995 .findByC_CD(companyId, createDate, start, end, 996 orderByComparator, retrieveFromCache); 997 } 998 999 /** 1000 * Returns the first user in the ordered set where companyId = ? and createDate = ?. 1001 * 1002 * @param companyId the company ID 1003 * @param createDate the create date 1004 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1005 * @return the first matching user 1006 * @throws NoSuchUserException if a matching user could not be found 1007 */ 1008 public static User findByC_CD_First(long companyId, Date createDate, 1009 OrderByComparator<User> orderByComparator) 1010 throws com.liferay.portal.exception.NoSuchUserException { 1011 return getPersistence() 1012 .findByC_CD_First(companyId, createDate, orderByComparator); 1013 } 1014 1015 /** 1016 * Returns the first user in the ordered set where companyId = ? and createDate = ?. 1017 * 1018 * @param companyId the company ID 1019 * @param createDate the create date 1020 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1021 * @return the first matching user, or <code>null</code> if a matching user could not be found 1022 */ 1023 public static User fetchByC_CD_First(long companyId, Date createDate, 1024 OrderByComparator<User> orderByComparator) { 1025 return getPersistence() 1026 .fetchByC_CD_First(companyId, createDate, orderByComparator); 1027 } 1028 1029 /** 1030 * Returns the last user in the ordered set where companyId = ? and createDate = ?. 1031 * 1032 * @param companyId the company ID 1033 * @param createDate the create date 1034 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1035 * @return the last matching user 1036 * @throws NoSuchUserException if a matching user could not be found 1037 */ 1038 public static User findByC_CD_Last(long companyId, Date createDate, 1039 OrderByComparator<User> orderByComparator) 1040 throws com.liferay.portal.exception.NoSuchUserException { 1041 return getPersistence() 1042 .findByC_CD_Last(companyId, createDate, orderByComparator); 1043 } 1044 1045 /** 1046 * Returns the last user in the ordered set where companyId = ? and createDate = ?. 1047 * 1048 * @param companyId the company ID 1049 * @param createDate the create date 1050 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1051 * @return the last matching user, or <code>null</code> if a matching user could not be found 1052 */ 1053 public static User fetchByC_CD_Last(long companyId, Date createDate, 1054 OrderByComparator<User> orderByComparator) { 1055 return getPersistence() 1056 .fetchByC_CD_Last(companyId, createDate, orderByComparator); 1057 } 1058 1059 /** 1060 * Returns the users before and after the current user in the ordered set where companyId = ? and createDate = ?. 1061 * 1062 * @param userId the primary key of the current user 1063 * @param companyId the company ID 1064 * @param createDate the create date 1065 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1066 * @return the previous, current, and next user 1067 * @throws NoSuchUserException if a user with the primary key could not be found 1068 */ 1069 public static User[] findByC_CD_PrevAndNext(long userId, long companyId, 1070 Date createDate, OrderByComparator<User> orderByComparator) 1071 throws com.liferay.portal.exception.NoSuchUserException { 1072 return getPersistence() 1073 .findByC_CD_PrevAndNext(userId, companyId, createDate, 1074 orderByComparator); 1075 } 1076 1077 /** 1078 * Removes all the users where companyId = ? and createDate = ? from the database. 1079 * 1080 * @param companyId the company ID 1081 * @param createDate the create date 1082 */ 1083 public static void removeByC_CD(long companyId, Date createDate) { 1084 getPersistence().removeByC_CD(companyId, createDate); 1085 } 1086 1087 /** 1088 * Returns the number of users where companyId = ? and createDate = ?. 1089 * 1090 * @param companyId the company ID 1091 * @param createDate the create date 1092 * @return the number of matching users 1093 */ 1094 public static int countByC_CD(long companyId, Date createDate) { 1095 return getPersistence().countByC_CD(companyId, createDate); 1096 } 1097 1098 /** 1099 * Returns all the users where companyId = ? and modifiedDate = ?. 1100 * 1101 * @param companyId the company ID 1102 * @param modifiedDate the modified date 1103 * @return the matching users 1104 */ 1105 public static List<User> findByC_MD(long companyId, Date modifiedDate) { 1106 return getPersistence().findByC_MD(companyId, modifiedDate); 1107 } 1108 1109 /** 1110 * Returns a range of all the users where companyId = ? and modifiedDate = ?. 1111 * 1112 * <p> 1113 * 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 UserModelImpl}. 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. 1114 * </p> 1115 * 1116 * @param companyId the company ID 1117 * @param modifiedDate the modified date 1118 * @param start the lower bound of the range of users 1119 * @param end the upper bound of the range of users (not inclusive) 1120 * @return the range of matching users 1121 */ 1122 public static List<User> findByC_MD(long companyId, Date modifiedDate, 1123 int start, int end) { 1124 return getPersistence().findByC_MD(companyId, modifiedDate, start, end); 1125 } 1126 1127 /** 1128 * Returns an ordered range of all the users where companyId = ? and modifiedDate = ?. 1129 * 1130 * <p> 1131 * 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 UserModelImpl}. 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. 1132 * </p> 1133 * 1134 * @param companyId the company ID 1135 * @param modifiedDate the modified date 1136 * @param start the lower bound of the range of users 1137 * @param end the upper bound of the range of users (not inclusive) 1138 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1139 * @return the ordered range of matching users 1140 */ 1141 public static List<User> findByC_MD(long companyId, Date modifiedDate, 1142 int start, int end, OrderByComparator<User> orderByComparator) { 1143 return getPersistence() 1144 .findByC_MD(companyId, modifiedDate, start, end, 1145 orderByComparator); 1146 } 1147 1148 /** 1149 * Returns an ordered range of all the users where companyId = ? and modifiedDate = ?. 1150 * 1151 * <p> 1152 * 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 UserModelImpl}. 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. 1153 * </p> 1154 * 1155 * @param companyId the company ID 1156 * @param modifiedDate the modified date 1157 * @param start the lower bound of the range of users 1158 * @param end the upper bound of the range of users (not inclusive) 1159 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1160 * @param retrieveFromCache whether to retrieve from the finder cache 1161 * @return the ordered range of matching users 1162 */ 1163 public static List<User> findByC_MD(long companyId, Date modifiedDate, 1164 int start, int end, OrderByComparator<User> orderByComparator, 1165 boolean retrieveFromCache) { 1166 return getPersistence() 1167 .findByC_MD(companyId, modifiedDate, start, end, 1168 orderByComparator, retrieveFromCache); 1169 } 1170 1171 /** 1172 * Returns the first user in the ordered set where companyId = ? and modifiedDate = ?. 1173 * 1174 * @param companyId the company ID 1175 * @param modifiedDate the modified date 1176 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1177 * @return the first matching user 1178 * @throws NoSuchUserException if a matching user could not be found 1179 */ 1180 public static User findByC_MD_First(long companyId, Date modifiedDate, 1181 OrderByComparator<User> orderByComparator) 1182 throws com.liferay.portal.exception.NoSuchUserException { 1183 return getPersistence() 1184 .findByC_MD_First(companyId, modifiedDate, orderByComparator); 1185 } 1186 1187 /** 1188 * Returns the first user in the ordered set where companyId = ? and modifiedDate = ?. 1189 * 1190 * @param companyId the company ID 1191 * @param modifiedDate the modified date 1192 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1193 * @return the first matching user, or <code>null</code> if a matching user could not be found 1194 */ 1195 public static User fetchByC_MD_First(long companyId, Date modifiedDate, 1196 OrderByComparator<User> orderByComparator) { 1197 return getPersistence() 1198 .fetchByC_MD_First(companyId, modifiedDate, orderByComparator); 1199 } 1200 1201 /** 1202 * Returns the last user in the ordered set where companyId = ? and modifiedDate = ?. 1203 * 1204 * @param companyId the company ID 1205 * @param modifiedDate the modified date 1206 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1207 * @return the last matching user 1208 * @throws NoSuchUserException if a matching user could not be found 1209 */ 1210 public static User findByC_MD_Last(long companyId, Date modifiedDate, 1211 OrderByComparator<User> orderByComparator) 1212 throws com.liferay.portal.exception.NoSuchUserException { 1213 return getPersistence() 1214 .findByC_MD_Last(companyId, modifiedDate, orderByComparator); 1215 } 1216 1217 /** 1218 * Returns the last user in the ordered set where companyId = ? and modifiedDate = ?. 1219 * 1220 * @param companyId the company ID 1221 * @param modifiedDate the modified date 1222 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1223 * @return the last matching user, or <code>null</code> if a matching user could not be found 1224 */ 1225 public static User fetchByC_MD_Last(long companyId, Date modifiedDate, 1226 OrderByComparator<User> orderByComparator) { 1227 return getPersistence() 1228 .fetchByC_MD_Last(companyId, modifiedDate, orderByComparator); 1229 } 1230 1231 /** 1232 * Returns the users before and after the current user in the ordered set where companyId = ? and modifiedDate = ?. 1233 * 1234 * @param userId the primary key of the current user 1235 * @param companyId the company ID 1236 * @param modifiedDate the modified date 1237 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1238 * @return the previous, current, and next user 1239 * @throws NoSuchUserException if a user with the primary key could not be found 1240 */ 1241 public static User[] findByC_MD_PrevAndNext(long userId, long companyId, 1242 Date modifiedDate, OrderByComparator<User> orderByComparator) 1243 throws com.liferay.portal.exception.NoSuchUserException { 1244 return getPersistence() 1245 .findByC_MD_PrevAndNext(userId, companyId, modifiedDate, 1246 orderByComparator); 1247 } 1248 1249 /** 1250 * Removes all the users where companyId = ? and modifiedDate = ? from the database. 1251 * 1252 * @param companyId the company ID 1253 * @param modifiedDate the modified date 1254 */ 1255 public static void removeByC_MD(long companyId, Date modifiedDate) { 1256 getPersistence().removeByC_MD(companyId, modifiedDate); 1257 } 1258 1259 /** 1260 * Returns the number of users where companyId = ? and modifiedDate = ?. 1261 * 1262 * @param companyId the company ID 1263 * @param modifiedDate the modified date 1264 * @return the number of matching users 1265 */ 1266 public static int countByC_MD(long companyId, Date modifiedDate) { 1267 return getPersistence().countByC_MD(companyId, modifiedDate); 1268 } 1269 1270 /** 1271 * Returns the user where companyId = ? and defaultUser = ? or throws a {@link NoSuchUserException} if it could not be found. 1272 * 1273 * @param companyId the company ID 1274 * @param defaultUser the default user 1275 * @return the matching user 1276 * @throws NoSuchUserException if a matching user could not be found 1277 */ 1278 public static User findByC_DU(long companyId, boolean defaultUser) 1279 throws com.liferay.portal.exception.NoSuchUserException { 1280 return getPersistence().findByC_DU(companyId, defaultUser); 1281 } 1282 1283 /** 1284 * Returns the user where companyId = ? and defaultUser = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 1285 * 1286 * @param companyId the company ID 1287 * @param defaultUser the default user 1288 * @return the matching user, or <code>null</code> if a matching user could not be found 1289 */ 1290 public static User fetchByC_DU(long companyId, boolean defaultUser) { 1291 return getPersistence().fetchByC_DU(companyId, defaultUser); 1292 } 1293 1294 /** 1295 * Returns the user where companyId = ? and defaultUser = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 1296 * 1297 * @param companyId the company ID 1298 * @param defaultUser the default user 1299 * @param retrieveFromCache whether to retrieve from the finder cache 1300 * @return the matching user, or <code>null</code> if a matching user could not be found 1301 */ 1302 public static User fetchByC_DU(long companyId, boolean defaultUser, 1303 boolean retrieveFromCache) { 1304 return getPersistence() 1305 .fetchByC_DU(companyId, defaultUser, retrieveFromCache); 1306 } 1307 1308 /** 1309 * Removes the user where companyId = ? and defaultUser = ? from the database. 1310 * 1311 * @param companyId the company ID 1312 * @param defaultUser the default user 1313 * @return the user that was removed 1314 */ 1315 public static User removeByC_DU(long companyId, boolean defaultUser) 1316 throws com.liferay.portal.exception.NoSuchUserException { 1317 return getPersistence().removeByC_DU(companyId, defaultUser); 1318 } 1319 1320 /** 1321 * Returns the number of users where companyId = ? and defaultUser = ?. 1322 * 1323 * @param companyId the company ID 1324 * @param defaultUser the default user 1325 * @return the number of matching users 1326 */ 1327 public static int countByC_DU(long companyId, boolean defaultUser) { 1328 return getPersistence().countByC_DU(companyId, defaultUser); 1329 } 1330 1331 /** 1332 * Returns the user where companyId = ? and screenName = ? or throws a {@link NoSuchUserException} if it could not be found. 1333 * 1334 * @param companyId the company ID 1335 * @param screenName the screen name 1336 * @return the matching user 1337 * @throws NoSuchUserException if a matching user could not be found 1338 */ 1339 public static User findByC_SN(long companyId, java.lang.String screenName) 1340 throws com.liferay.portal.exception.NoSuchUserException { 1341 return getPersistence().findByC_SN(companyId, screenName); 1342 } 1343 1344 /** 1345 * Returns the user where companyId = ? and screenName = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 1346 * 1347 * @param companyId the company ID 1348 * @param screenName the screen name 1349 * @return the matching user, or <code>null</code> if a matching user could not be found 1350 */ 1351 public static User fetchByC_SN(long companyId, java.lang.String screenName) { 1352 return getPersistence().fetchByC_SN(companyId, screenName); 1353 } 1354 1355 /** 1356 * Returns the user where companyId = ? and screenName = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 1357 * 1358 * @param companyId the company ID 1359 * @param screenName the screen name 1360 * @param retrieveFromCache whether to retrieve from the finder cache 1361 * @return the matching user, or <code>null</code> if a matching user could not be found 1362 */ 1363 public static User fetchByC_SN(long companyId, java.lang.String screenName, 1364 boolean retrieveFromCache) { 1365 return getPersistence() 1366 .fetchByC_SN(companyId, screenName, retrieveFromCache); 1367 } 1368 1369 /** 1370 * Removes the user where companyId = ? and screenName = ? from the database. 1371 * 1372 * @param companyId the company ID 1373 * @param screenName the screen name 1374 * @return the user that was removed 1375 */ 1376 public static User removeByC_SN(long companyId, java.lang.String screenName) 1377 throws com.liferay.portal.exception.NoSuchUserException { 1378 return getPersistence().removeByC_SN(companyId, screenName); 1379 } 1380 1381 /** 1382 * Returns the number of users where companyId = ? and screenName = ?. 1383 * 1384 * @param companyId the company ID 1385 * @param screenName the screen name 1386 * @return the number of matching users 1387 */ 1388 public static int countByC_SN(long companyId, java.lang.String screenName) { 1389 return getPersistence().countByC_SN(companyId, screenName); 1390 } 1391 1392 /** 1393 * Returns the user where companyId = ? and emailAddress = ? or throws a {@link NoSuchUserException} if it could not be found. 1394 * 1395 * @param companyId the company ID 1396 * @param emailAddress the email address 1397 * @return the matching user 1398 * @throws NoSuchUserException if a matching user could not be found 1399 */ 1400 public static User findByC_EA(long companyId, java.lang.String emailAddress) 1401 throws com.liferay.portal.exception.NoSuchUserException { 1402 return getPersistence().findByC_EA(companyId, emailAddress); 1403 } 1404 1405 /** 1406 * Returns the user where companyId = ? and emailAddress = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 1407 * 1408 * @param companyId the company ID 1409 * @param emailAddress the email address 1410 * @return the matching user, or <code>null</code> if a matching user could not be found 1411 */ 1412 public static User fetchByC_EA(long companyId, java.lang.String emailAddress) { 1413 return getPersistence().fetchByC_EA(companyId, emailAddress); 1414 } 1415 1416 /** 1417 * Returns the user where companyId = ? and emailAddress = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 1418 * 1419 * @param companyId the company ID 1420 * @param emailAddress the email address 1421 * @param retrieveFromCache whether to retrieve from the finder cache 1422 * @return the matching user, or <code>null</code> if a matching user could not be found 1423 */ 1424 public static User fetchByC_EA(long companyId, 1425 java.lang.String emailAddress, boolean retrieveFromCache) { 1426 return getPersistence() 1427 .fetchByC_EA(companyId, emailAddress, retrieveFromCache); 1428 } 1429 1430 /** 1431 * Removes the user where companyId = ? and emailAddress = ? from the database. 1432 * 1433 * @param companyId the company ID 1434 * @param emailAddress the email address 1435 * @return the user that was removed 1436 */ 1437 public static User removeByC_EA(long companyId, 1438 java.lang.String emailAddress) 1439 throws com.liferay.portal.exception.NoSuchUserException { 1440 return getPersistence().removeByC_EA(companyId, emailAddress); 1441 } 1442 1443 /** 1444 * Returns the number of users where companyId = ? and emailAddress = ?. 1445 * 1446 * @param companyId the company ID 1447 * @param emailAddress the email address 1448 * @return the number of matching users 1449 */ 1450 public static int countByC_EA(long companyId, java.lang.String emailAddress) { 1451 return getPersistence().countByC_EA(companyId, emailAddress); 1452 } 1453 1454 /** 1455 * Returns the user where companyId = ? and facebookId = ? or throws a {@link NoSuchUserException} if it could not be found. 1456 * 1457 * @param companyId the company ID 1458 * @param facebookId the facebook ID 1459 * @return the matching user 1460 * @throws NoSuchUserException if a matching user could not be found 1461 */ 1462 public static User findByC_FID(long companyId, long facebookId) 1463 throws com.liferay.portal.exception.NoSuchUserException { 1464 return getPersistence().findByC_FID(companyId, facebookId); 1465 } 1466 1467 /** 1468 * Returns the user where companyId = ? and facebookId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 1469 * 1470 * @param companyId the company ID 1471 * @param facebookId the facebook ID 1472 * @return the matching user, or <code>null</code> if a matching user could not be found 1473 */ 1474 public static User fetchByC_FID(long companyId, long facebookId) { 1475 return getPersistence().fetchByC_FID(companyId, facebookId); 1476 } 1477 1478 /** 1479 * Returns the user where companyId = ? and facebookId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 1480 * 1481 * @param companyId the company ID 1482 * @param facebookId the facebook ID 1483 * @param retrieveFromCache whether to retrieve from the finder cache 1484 * @return the matching user, or <code>null</code> if a matching user could not be found 1485 */ 1486 public static User fetchByC_FID(long companyId, long facebookId, 1487 boolean retrieveFromCache) { 1488 return getPersistence() 1489 .fetchByC_FID(companyId, facebookId, retrieveFromCache); 1490 } 1491 1492 /** 1493 * Removes the user where companyId = ? and facebookId = ? from the database. 1494 * 1495 * @param companyId the company ID 1496 * @param facebookId the facebook ID 1497 * @return the user that was removed 1498 */ 1499 public static User removeByC_FID(long companyId, long facebookId) 1500 throws com.liferay.portal.exception.NoSuchUserException { 1501 return getPersistence().removeByC_FID(companyId, facebookId); 1502 } 1503 1504 /** 1505 * Returns the number of users where companyId = ? and facebookId = ?. 1506 * 1507 * @param companyId the company ID 1508 * @param facebookId the facebook ID 1509 * @return the number of matching users 1510 */ 1511 public static int countByC_FID(long companyId, long facebookId) { 1512 return getPersistence().countByC_FID(companyId, facebookId); 1513 } 1514 1515 /** 1516 * Returns the user where companyId = ? and openId = ? or throws a {@link NoSuchUserException} if it could not be found. 1517 * 1518 * @param companyId the company ID 1519 * @param openId the open ID 1520 * @return the matching user 1521 * @throws NoSuchUserException if a matching user could not be found 1522 */ 1523 public static User findByC_O(long companyId, java.lang.String openId) 1524 throws com.liferay.portal.exception.NoSuchUserException { 1525 return getPersistence().findByC_O(companyId, openId); 1526 } 1527 1528 /** 1529 * Returns the user where companyId = ? and openId = ? or returns <code>null</code> if it could not be found. Uses the finder cache. 1530 * 1531 * @param companyId the company ID 1532 * @param openId the open ID 1533 * @return the matching user, or <code>null</code> if a matching user could not be found 1534 */ 1535 public static User fetchByC_O(long companyId, java.lang.String openId) { 1536 return getPersistence().fetchByC_O(companyId, openId); 1537 } 1538 1539 /** 1540 * Returns the user where companyId = ? and openId = ? or returns <code>null</code> if it could not be found, optionally using the finder cache. 1541 * 1542 * @param companyId the company ID 1543 * @param openId the open ID 1544 * @param retrieveFromCache whether to retrieve from the finder cache 1545 * @return the matching user, or <code>null</code> if a matching user could not be found 1546 */ 1547 public static User fetchByC_O(long companyId, java.lang.String openId, 1548 boolean retrieveFromCache) { 1549 return getPersistence().fetchByC_O(companyId, openId, retrieveFromCache); 1550 } 1551 1552 /** 1553 * Removes the user where companyId = ? and openId = ? from the database. 1554 * 1555 * @param companyId the company ID 1556 * @param openId the open ID 1557 * @return the user that was removed 1558 */ 1559 public static User removeByC_O(long companyId, java.lang.String openId) 1560 throws com.liferay.portal.exception.NoSuchUserException { 1561 return getPersistence().removeByC_O(companyId, openId); 1562 } 1563 1564 /** 1565 * Returns the number of users where companyId = ? and openId = ?. 1566 * 1567 * @param companyId the company ID 1568 * @param openId the open ID 1569 * @return the number of matching users 1570 */ 1571 public static int countByC_O(long companyId, java.lang.String openId) { 1572 return getPersistence().countByC_O(companyId, openId); 1573 } 1574 1575 /** 1576 * Returns all the users where companyId = ? and status = ?. 1577 * 1578 * @param companyId the company ID 1579 * @param status the status 1580 * @return the matching users 1581 */ 1582 public static List<User> findByC_S(long companyId, int status) { 1583 return getPersistence().findByC_S(companyId, status); 1584 } 1585 1586 /** 1587 * Returns a range of all the users where companyId = ? and status = ?. 1588 * 1589 * <p> 1590 * 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 UserModelImpl}. 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. 1591 * </p> 1592 * 1593 * @param companyId the company ID 1594 * @param status the status 1595 * @param start the lower bound of the range of users 1596 * @param end the upper bound of the range of users (not inclusive) 1597 * @return the range of matching users 1598 */ 1599 public static List<User> findByC_S(long companyId, int status, int start, 1600 int end) { 1601 return getPersistence().findByC_S(companyId, status, start, end); 1602 } 1603 1604 /** 1605 * Returns an ordered range of all the users where companyId = ? and status = ?. 1606 * 1607 * <p> 1608 * 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 UserModelImpl}. 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. 1609 * </p> 1610 * 1611 * @param companyId the company ID 1612 * @param status the status 1613 * @param start the lower bound of the range of users 1614 * @param end the upper bound of the range of users (not inclusive) 1615 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1616 * @return the ordered range of matching users 1617 */ 1618 public static List<User> findByC_S(long companyId, int status, int start, 1619 int end, OrderByComparator<User> orderByComparator) { 1620 return getPersistence() 1621 .findByC_S(companyId, status, start, end, orderByComparator); 1622 } 1623 1624 /** 1625 * Returns an ordered range of all the users where companyId = ? and status = ?. 1626 * 1627 * <p> 1628 * Useful when paginating results. Returns a maximum of <code>end - start</code> instances. <code>start</code> and <code>end</code> are not primary keys, they are indexes in the result set. Thus, <code>0</code> refers to the first result in the set. Setting both <code>start</code> and <code>end</code> to {@link 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 UserModelImpl}. If both <code>orderByComparator</code> and pagination are absent, for performance reasons, the query will not have an ORDER BY clause and the returned result set will be sorted on by the primary key in an ascending order. 1629 * </p> 1630 * 1631 * @param companyId the company ID 1632 * @param status the status 1633 * @param start the lower bound of the range of users 1634 * @param end the upper bound of the range of users (not inclusive) 1635 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1636 * @param retrieveFromCache whether to retrieve from the finder cache 1637 * @return the ordered range of matching users 1638 */ 1639 public static List<User> findByC_S(long companyId, int status, int start, 1640 int end, OrderByComparator<User> orderByComparator, 1641 boolean retrieveFromCache) { 1642 return getPersistence() 1643 .findByC_S(companyId, status, start, end, orderByComparator, 1644 retrieveFromCache); 1645 } 1646 1647 /** 1648 * Returns the first user in the ordered set where companyId = ? and status = ?. 1649 * 1650 * @param companyId the company ID 1651 * @param status the status 1652 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1653 * @return the first matching user 1654 * @throws NoSuchUserException if a matching user could not be found 1655 */ 1656 public static User findByC_S_First(long companyId, int status, 1657 OrderByComparator<User> orderByComparator) 1658 throws com.liferay.portal.exception.NoSuchUserException { 1659 return getPersistence() 1660 .findByC_S_First(companyId, status, orderByComparator); 1661 } 1662 1663 /** 1664 * Returns the first user in the ordered set where companyId = ? and status = ?. 1665 * 1666 * @param companyId the company ID 1667 * @param status the status 1668 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1669 * @return the first matching user, or <code>null</code> if a matching user could not be found 1670 */ 1671 public static User fetchByC_S_First(long companyId, int status, 1672 OrderByComparator<User> orderByComparator) { 1673 return getPersistence() 1674 .fetchByC_S_First(companyId, status, orderByComparator); 1675 } 1676 1677 /** 1678 * Returns the last user in the ordered set where companyId = ? and status = ?. 1679 * 1680 * @param companyId the company ID 1681 * @param status the status 1682 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1683 * @return the last matching user 1684 * @throws NoSuchUserException if a matching user could not be found 1685 */ 1686 public static User findByC_S_Last(long companyId, int status, 1687 OrderByComparator<User> orderByComparator) 1688 throws com.liferay.portal.exception.NoSuchUserException { 1689 return getPersistence() 1690 .findByC_S_Last(companyId, status, orderByComparator); 1691 } 1692 1693 /** 1694 * Returns the last user in the ordered set where companyId = ? and status = ?. 1695 * 1696 * @param companyId the company ID 1697 * @param status the status 1698 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1699 * @return the last matching user, or <code>null</code> if a matching user could not be found 1700 */ 1701 public static User fetchByC_S_Last(long companyId, int status, 1702 OrderByComparator<User> orderByComparator) { 1703 return getPersistence() 1704 .fetchByC_S_Last(companyId, status, orderByComparator); 1705 } 1706 1707 /** 1708 * Returns the users before and after the current user in the ordered set where companyId = ? and status = ?. 1709 * 1710 * @param userId the primary key of the current user 1711 * @param companyId the company ID 1712 * @param status the status 1713 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1714 * @return the previous, current, and next user 1715 * @throws NoSuchUserException if a user with the primary key could not be found 1716 */ 1717 public static User[] findByC_S_PrevAndNext(long userId, long companyId, 1718 int status, OrderByComparator<User> orderByComparator) 1719 throws com.liferay.portal.exception.NoSuchUserException { 1720 return getPersistence() 1721 .findByC_S_PrevAndNext(userId, companyId, status, 1722 orderByComparator); 1723 } 1724 1725 /** 1726 * Removes all the users where companyId = ? and status = ? from the database. 1727 * 1728 * @param companyId the company ID 1729 * @param status the status 1730 */ 1731 public static void removeByC_S(long companyId, int status) { 1732 getPersistence().removeByC_S(companyId, status); 1733 } 1734 1735 /** 1736 * Returns the number of users where companyId = ? and status = ?. 1737 * 1738 * @param companyId the company ID 1739 * @param status the status 1740 * @return the number of matching users 1741 */ 1742 public static int countByC_S(long companyId, int status) { 1743 return getPersistence().countByC_S(companyId, status); 1744 } 1745 1746 /** 1747 * Returns all the users where companyId = ? and createDate = ? and modifiedDate = ?. 1748 * 1749 * @param companyId the company ID 1750 * @param createDate the create date 1751 * @param modifiedDate the modified date 1752 * @return the matching users 1753 */ 1754 public static List<User> findByC_CD_MD(long companyId, Date createDate, 1755 Date modifiedDate) { 1756 return getPersistence() 1757 .findByC_CD_MD(companyId, createDate, modifiedDate); 1758 } 1759 1760 /** 1761 * Returns a range of all the users where companyId = ? and createDate = ? and modifiedDate = ?. 1762 * 1763 * <p> 1764 * 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 UserModelImpl}. 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. 1765 * </p> 1766 * 1767 * @param companyId the company ID 1768 * @param createDate the create date 1769 * @param modifiedDate the modified date 1770 * @param start the lower bound of the range of users 1771 * @param end the upper bound of the range of users (not inclusive) 1772 * @return the range of matching users 1773 */ 1774 public static List<User> findByC_CD_MD(long companyId, Date createDate, 1775 Date modifiedDate, int start, int end) { 1776 return getPersistence() 1777 .findByC_CD_MD(companyId, createDate, modifiedDate, start, 1778 end); 1779 } 1780 1781 /** 1782 * Returns an ordered range of all the users where companyId = ? and createDate = ? and modifiedDate = ?. 1783 * 1784 * <p> 1785 * 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 UserModelImpl}. 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. 1786 * </p> 1787 * 1788 * @param companyId the company ID 1789 * @param createDate the create date 1790 * @param modifiedDate the modified date 1791 * @param start the lower bound of the range of users 1792 * @param end the upper bound of the range of users (not inclusive) 1793 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1794 * @return the ordered range of matching users 1795 */ 1796 public static List<User> findByC_CD_MD(long companyId, Date createDate, 1797 Date modifiedDate, int start, int end, 1798 OrderByComparator<User> orderByComparator) { 1799 return getPersistence() 1800 .findByC_CD_MD(companyId, createDate, modifiedDate, start, 1801 end, orderByComparator); 1802 } 1803 1804 /** 1805 * Returns an ordered range of all the users where companyId = ? and createDate = ? and modifiedDate = ?. 1806 * 1807 * <p> 1808 * 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 UserModelImpl}. 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. 1809 * </p> 1810 * 1811 * @param companyId the company ID 1812 * @param createDate the create date 1813 * @param modifiedDate the modified date 1814 * @param start the lower bound of the range of users 1815 * @param end the upper bound of the range of users (not inclusive) 1816 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1817 * @param retrieveFromCache whether to retrieve from the finder cache 1818 * @return the ordered range of matching users 1819 */ 1820 public static List<User> findByC_CD_MD(long companyId, Date createDate, 1821 Date modifiedDate, int start, int end, 1822 OrderByComparator<User> orderByComparator, boolean retrieveFromCache) { 1823 return getPersistence() 1824 .findByC_CD_MD(companyId, createDate, modifiedDate, start, 1825 end, orderByComparator, retrieveFromCache); 1826 } 1827 1828 /** 1829 * Returns the first user in the ordered set where companyId = ? and createDate = ? and modifiedDate = ?. 1830 * 1831 * @param companyId the company ID 1832 * @param createDate the create date 1833 * @param modifiedDate the modified date 1834 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1835 * @return the first matching user 1836 * @throws NoSuchUserException if a matching user could not be found 1837 */ 1838 public static User findByC_CD_MD_First(long companyId, Date createDate, 1839 Date modifiedDate, OrderByComparator<User> orderByComparator) 1840 throws com.liferay.portal.exception.NoSuchUserException { 1841 return getPersistence() 1842 .findByC_CD_MD_First(companyId, createDate, modifiedDate, 1843 orderByComparator); 1844 } 1845 1846 /** 1847 * Returns the first user in the ordered set where companyId = ? and createDate = ? and modifiedDate = ?. 1848 * 1849 * @param companyId the company ID 1850 * @param createDate the create date 1851 * @param modifiedDate the modified date 1852 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1853 * @return the first matching user, or <code>null</code> if a matching user could not be found 1854 */ 1855 public static User fetchByC_CD_MD_First(long companyId, Date createDate, 1856 Date modifiedDate, OrderByComparator<User> orderByComparator) { 1857 return getPersistence() 1858 .fetchByC_CD_MD_First(companyId, createDate, modifiedDate, 1859 orderByComparator); 1860 } 1861 1862 /** 1863 * Returns the last user in the ordered set where companyId = ? and createDate = ? and modifiedDate = ?. 1864 * 1865 * @param companyId the company ID 1866 * @param createDate the create date 1867 * @param modifiedDate the modified date 1868 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1869 * @return the last matching user 1870 * @throws NoSuchUserException if a matching user could not be found 1871 */ 1872 public static User findByC_CD_MD_Last(long companyId, Date createDate, 1873 Date modifiedDate, OrderByComparator<User> orderByComparator) 1874 throws com.liferay.portal.exception.NoSuchUserException { 1875 return getPersistence() 1876 .findByC_CD_MD_Last(companyId, createDate, modifiedDate, 1877 orderByComparator); 1878 } 1879 1880 /** 1881 * Returns the last user in the ordered set where companyId = ? and createDate = ? and modifiedDate = ?. 1882 * 1883 * @param companyId the company ID 1884 * @param createDate the create date 1885 * @param modifiedDate the modified date 1886 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1887 * @return the last matching user, or <code>null</code> if a matching user could not be found 1888 */ 1889 public static User fetchByC_CD_MD_Last(long companyId, Date createDate, 1890 Date modifiedDate, OrderByComparator<User> orderByComparator) { 1891 return getPersistence() 1892 .fetchByC_CD_MD_Last(companyId, createDate, modifiedDate, 1893 orderByComparator); 1894 } 1895 1896 /** 1897 * Returns the users before and after the current user in the ordered set where companyId = ? and createDate = ? and modifiedDate = ?. 1898 * 1899 * @param userId the primary key of the current user 1900 * @param companyId the company ID 1901 * @param createDate the create date 1902 * @param modifiedDate the modified date 1903 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 1904 * @return the previous, current, and next user 1905 * @throws NoSuchUserException if a user with the primary key could not be found 1906 */ 1907 public static User[] findByC_CD_MD_PrevAndNext(long userId, long companyId, 1908 Date createDate, Date modifiedDate, 1909 OrderByComparator<User> orderByComparator) 1910 throws com.liferay.portal.exception.NoSuchUserException { 1911 return getPersistence() 1912 .findByC_CD_MD_PrevAndNext(userId, companyId, createDate, 1913 modifiedDate, orderByComparator); 1914 } 1915 1916 /** 1917 * Removes all the users where companyId = ? and createDate = ? and modifiedDate = ? from the database. 1918 * 1919 * @param companyId the company ID 1920 * @param createDate the create date 1921 * @param modifiedDate the modified date 1922 */ 1923 public static void removeByC_CD_MD(long companyId, Date createDate, 1924 Date modifiedDate) { 1925 getPersistence().removeByC_CD_MD(companyId, createDate, modifiedDate); 1926 } 1927 1928 /** 1929 * Returns the number of users where companyId = ? and createDate = ? and modifiedDate = ?. 1930 * 1931 * @param companyId the company ID 1932 * @param createDate the create date 1933 * @param modifiedDate the modified date 1934 * @return the number of matching users 1935 */ 1936 public static int countByC_CD_MD(long companyId, Date createDate, 1937 Date modifiedDate) { 1938 return getPersistence() 1939 .countByC_CD_MD(companyId, createDate, modifiedDate); 1940 } 1941 1942 /** 1943 * Returns all the users where companyId = ? and defaultUser = ? and status = ?. 1944 * 1945 * @param companyId the company ID 1946 * @param defaultUser the default user 1947 * @param status the status 1948 * @return the matching users 1949 */ 1950 public static List<User> findByC_DU_S(long companyId, boolean defaultUser, 1951 int status) { 1952 return getPersistence().findByC_DU_S(companyId, defaultUser, status); 1953 } 1954 1955 /** 1956 * Returns a range of all the users where companyId = ? and defaultUser = ? and status = ?. 1957 * 1958 * <p> 1959 * 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 UserModelImpl}. 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. 1960 * </p> 1961 * 1962 * @param companyId the company ID 1963 * @param defaultUser the default user 1964 * @param status the status 1965 * @param start the lower bound of the range of users 1966 * @param end the upper bound of the range of users (not inclusive) 1967 * @return the range of matching users 1968 */ 1969 public static List<User> findByC_DU_S(long companyId, boolean defaultUser, 1970 int status, int start, int end) { 1971 return getPersistence() 1972 .findByC_DU_S(companyId, defaultUser, status, start, end); 1973 } 1974 1975 /** 1976 * Returns an ordered range of all the users where companyId = ? and defaultUser = ? and status = ?. 1977 * 1978 * <p> 1979 * 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 UserModelImpl}. 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. 1980 * </p> 1981 * 1982 * @param companyId the company ID 1983 * @param defaultUser the default user 1984 * @param status the status 1985 * @param start the lower bound of the range of users 1986 * @param end the upper bound of the range of users (not inclusive) 1987 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 1988 * @return the ordered range of matching users 1989 */ 1990 public static List<User> findByC_DU_S(long companyId, boolean defaultUser, 1991 int status, int start, int end, 1992 OrderByComparator<User> orderByComparator) { 1993 return getPersistence() 1994 .findByC_DU_S(companyId, defaultUser, status, start, end, 1995 orderByComparator); 1996 } 1997 1998 /** 1999 * Returns an ordered range of all the users where companyId = ? and defaultUser = ? and status = ?. 2000 * 2001 * <p> 2002 * 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 UserModelImpl}. 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. 2003 * </p> 2004 * 2005 * @param companyId the company ID 2006 * @param defaultUser the default user 2007 * @param status the status 2008 * @param start the lower bound of the range of users 2009 * @param end the upper bound of the range of users (not inclusive) 2010 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2011 * @param retrieveFromCache whether to retrieve from the finder cache 2012 * @return the ordered range of matching users 2013 */ 2014 public static List<User> findByC_DU_S(long companyId, boolean defaultUser, 2015 int status, int start, int end, 2016 OrderByComparator<User> orderByComparator, boolean retrieveFromCache) { 2017 return getPersistence() 2018 .findByC_DU_S(companyId, defaultUser, status, start, end, 2019 orderByComparator, retrieveFromCache); 2020 } 2021 2022 /** 2023 * Returns the first user in the ordered set where companyId = ? and defaultUser = ? and status = ?. 2024 * 2025 * @param companyId the company ID 2026 * @param defaultUser the default user 2027 * @param status the status 2028 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2029 * @return the first matching user 2030 * @throws NoSuchUserException if a matching user could not be found 2031 */ 2032 public static User findByC_DU_S_First(long companyId, boolean defaultUser, 2033 int status, OrderByComparator<User> orderByComparator) 2034 throws com.liferay.portal.exception.NoSuchUserException { 2035 return getPersistence() 2036 .findByC_DU_S_First(companyId, defaultUser, status, 2037 orderByComparator); 2038 } 2039 2040 /** 2041 * Returns the first user in the ordered set where companyId = ? and defaultUser = ? and status = ?. 2042 * 2043 * @param companyId the company ID 2044 * @param defaultUser the default user 2045 * @param status the status 2046 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2047 * @return the first matching user, or <code>null</code> if a matching user could not be found 2048 */ 2049 public static User fetchByC_DU_S_First(long companyId, boolean defaultUser, 2050 int status, OrderByComparator<User> orderByComparator) { 2051 return getPersistence() 2052 .fetchByC_DU_S_First(companyId, defaultUser, status, 2053 orderByComparator); 2054 } 2055 2056 /** 2057 * Returns the last user in the ordered set where companyId = ? and defaultUser = ? and status = ?. 2058 * 2059 * @param companyId the company ID 2060 * @param defaultUser the default user 2061 * @param status the status 2062 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2063 * @return the last matching user 2064 * @throws NoSuchUserException if a matching user could not be found 2065 */ 2066 public static User findByC_DU_S_Last(long companyId, boolean defaultUser, 2067 int status, OrderByComparator<User> orderByComparator) 2068 throws com.liferay.portal.exception.NoSuchUserException { 2069 return getPersistence() 2070 .findByC_DU_S_Last(companyId, defaultUser, status, 2071 orderByComparator); 2072 } 2073 2074 /** 2075 * Returns the last user in the ordered set where companyId = ? and defaultUser = ? and status = ?. 2076 * 2077 * @param companyId the company ID 2078 * @param defaultUser the default user 2079 * @param status the status 2080 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2081 * @return the last matching user, or <code>null</code> if a matching user could not be found 2082 */ 2083 public static User fetchByC_DU_S_Last(long companyId, boolean defaultUser, 2084 int status, OrderByComparator<User> orderByComparator) { 2085 return getPersistence() 2086 .fetchByC_DU_S_Last(companyId, defaultUser, status, 2087 orderByComparator); 2088 } 2089 2090 /** 2091 * Returns the users before and after the current user in the ordered set where companyId = ? and defaultUser = ? and status = ?. 2092 * 2093 * @param userId the primary key of the current user 2094 * @param companyId the company ID 2095 * @param defaultUser the default user 2096 * @param status the status 2097 * @param orderByComparator the comparator to order the set by (optionally <code>null</code>) 2098 * @return the previous, current, and next user 2099 * @throws NoSuchUserException if a user with the primary key could not be found 2100 */ 2101 public static User[] findByC_DU_S_PrevAndNext(long userId, long companyId, 2102 boolean defaultUser, int status, 2103 OrderByComparator<User> orderByComparator) 2104 throws com.liferay.portal.exception.NoSuchUserException { 2105 return getPersistence() 2106 .findByC_DU_S_PrevAndNext(userId, companyId, defaultUser, 2107 status, orderByComparator); 2108 } 2109 2110 /** 2111 * Removes all the users where companyId = ? and defaultUser = ? and status = ? from the database. 2112 * 2113 * @param companyId the company ID 2114 * @param defaultUser the default user 2115 * @param status the status 2116 */ 2117 public static void removeByC_DU_S(long companyId, boolean defaultUser, 2118 int status) { 2119 getPersistence().removeByC_DU_S(companyId, defaultUser, status); 2120 } 2121 2122 /** 2123 * Returns the number of users where companyId = ? and defaultUser = ? and status = ?. 2124 * 2125 * @param companyId the company ID 2126 * @param defaultUser the default user 2127 * @param status the status 2128 * @return the number of matching users 2129 */ 2130 public static int countByC_DU_S(long companyId, boolean defaultUser, 2131 int status) { 2132 return getPersistence().countByC_DU_S(companyId, defaultUser, status); 2133 } 2134 2135 /** 2136 * Caches the user in the entity cache if it is enabled. 2137 * 2138 * @param user the user 2139 */ 2140 public static void cacheResult(User user) { 2141 getPersistence().cacheResult(user); 2142 } 2143 2144 /** 2145 * Caches the users in the entity cache if it is enabled. 2146 * 2147 * @param users the users 2148 */ 2149 public static void cacheResult(List<User> users) { 2150 getPersistence().cacheResult(users); 2151 } 2152 2153 /** 2154 * Creates a new user with the primary key. Does not add the user to the database. 2155 * 2156 * @param userId the primary key for the new user 2157 * @return the new user 2158 */ 2159 public static User create(long userId) { 2160 return getPersistence().create(userId); 2161 } 2162 2163 /** 2164 * Removes the user with the primary key from the database. Also notifies the appropriate model listeners. 2165 * 2166 * @param userId the primary key of the user 2167 * @return the user that was removed 2168 * @throws NoSuchUserException if a user with the primary key could not be found 2169 */ 2170 public static User remove(long userId) 2171 throws com.liferay.portal.exception.NoSuchUserException { 2172 return getPersistence().remove(userId); 2173 } 2174 2175 public static User updateImpl(User user) { 2176 return getPersistence().updateImpl(user); 2177 } 2178 2179 /** 2180 * Returns the user with the primary key or throws a {@link NoSuchUserException} if it could not be found. 2181 * 2182 * @param userId the primary key of the user 2183 * @return the user 2184 * @throws NoSuchUserException if a user with the primary key could not be found 2185 */ 2186 public static User findByPrimaryKey(long userId) 2187 throws com.liferay.portal.exception.NoSuchUserException { 2188 return getPersistence().findByPrimaryKey(userId); 2189 } 2190 2191 /** 2192 * Returns the user with the primary key or returns <code>null</code> if it could not be found. 2193 * 2194 * @param userId the primary key of the user 2195 * @return the user, or <code>null</code> if a user with the primary key could not be found 2196 */ 2197 public static User fetchByPrimaryKey(long userId) { 2198 return getPersistence().fetchByPrimaryKey(userId); 2199 } 2200 2201 public static java.util.Map<java.io.Serializable, User> fetchByPrimaryKeys( 2202 java.util.Set<java.io.Serializable> primaryKeys) { 2203 return getPersistence().fetchByPrimaryKeys(primaryKeys); 2204 } 2205 2206 /** 2207 * Returns all the users. 2208 * 2209 * @return the users 2210 */ 2211 public static List<User> findAll() { 2212 return getPersistence().findAll(); 2213 } 2214 2215 /** 2216 * Returns a range of all the users. 2217 * 2218 * <p> 2219 * 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 UserModelImpl}. 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. 2220 * </p> 2221 * 2222 * @param start the lower bound of the range of users 2223 * @param end the upper bound of the range of users (not inclusive) 2224 * @return the range of users 2225 */ 2226 public static List<User> findAll(int start, int end) { 2227 return getPersistence().findAll(start, end); 2228 } 2229 2230 /** 2231 * Returns an ordered range of all the users. 2232 * 2233 * <p> 2234 * 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 UserModelImpl}. 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. 2235 * </p> 2236 * 2237 * @param start the lower bound of the range of users 2238 * @param end the upper bound of the range of users (not inclusive) 2239 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2240 * @return the ordered range of users 2241 */ 2242 public static List<User> findAll(int start, int end, 2243 OrderByComparator<User> orderByComparator) { 2244 return getPersistence().findAll(start, end, orderByComparator); 2245 } 2246 2247 /** 2248 * Returns an ordered range of all the users. 2249 * 2250 * <p> 2251 * 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 UserModelImpl}. 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. 2252 * </p> 2253 * 2254 * @param start the lower bound of the range of users 2255 * @param end the upper bound of the range of users (not inclusive) 2256 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2257 * @param retrieveFromCache whether to retrieve from the finder cache 2258 * @return the ordered range of users 2259 */ 2260 public static List<User> findAll(int start, int end, 2261 OrderByComparator<User> orderByComparator, boolean retrieveFromCache) { 2262 return getPersistence() 2263 .findAll(start, end, orderByComparator, retrieveFromCache); 2264 } 2265 2266 /** 2267 * Removes all the users from the database. 2268 */ 2269 public static void removeAll() { 2270 getPersistence().removeAll(); 2271 } 2272 2273 /** 2274 * Returns the number of users. 2275 * 2276 * @return the number of users 2277 */ 2278 public static int countAll() { 2279 return getPersistence().countAll(); 2280 } 2281 2282 /** 2283 * Returns the primaryKeys of groups associated with the user. 2284 * 2285 * @param pk the primary key of the user 2286 * @return long[] of the primaryKeys of groups associated with the user 2287 */ 2288 public static long[] getGroupPrimaryKeys(long pk) { 2289 return getPersistence().getGroupPrimaryKeys(pk); 2290 } 2291 2292 /** 2293 * Returns all the groups associated with the user. 2294 * 2295 * @param pk the primary key of the user 2296 * @return the groups associated with the user 2297 */ 2298 public static List<com.liferay.portal.model.Group> getGroups(long pk) { 2299 return getPersistence().getGroups(pk); 2300 } 2301 2302 /** 2303 * Returns a range of all the groups associated with the user. 2304 * 2305 * <p> 2306 * 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 UserModelImpl}. 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. 2307 * </p> 2308 * 2309 * @param pk the primary key of the user 2310 * @param start the lower bound of the range of users 2311 * @param end the upper bound of the range of users (not inclusive) 2312 * @return the range of groups associated with the user 2313 */ 2314 public static List<com.liferay.portal.model.Group> getGroups(long pk, 2315 int start, int end) { 2316 return getPersistence().getGroups(pk, start, end); 2317 } 2318 2319 /** 2320 * Returns an ordered range of all the groups associated with the user. 2321 * 2322 * <p> 2323 * 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 UserModelImpl}. 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. 2324 * </p> 2325 * 2326 * @param pk the primary key of the user 2327 * @param start the lower bound of the range of users 2328 * @param end the upper bound of the range of users (not inclusive) 2329 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2330 * @return the ordered range of groups associated with the user 2331 */ 2332 public static List<com.liferay.portal.model.Group> getGroups(long pk, 2333 int start, int end, 2334 OrderByComparator<com.liferay.portal.model.Group> orderByComparator) { 2335 return getPersistence().getGroups(pk, start, end, orderByComparator); 2336 } 2337 2338 /** 2339 * Returns the number of groups associated with the user. 2340 * 2341 * @param pk the primary key of the user 2342 * @return the number of groups associated with the user 2343 */ 2344 public static int getGroupsSize(long pk) { 2345 return getPersistence().getGroupsSize(pk); 2346 } 2347 2348 /** 2349 * Returns <code>true</code> if the group is associated with the user. 2350 * 2351 * @param pk the primary key of the user 2352 * @param groupPK the primary key of the group 2353 * @return <code>true</code> if the group is associated with the user; <code>false</code> otherwise 2354 */ 2355 public static boolean containsGroup(long pk, long groupPK) { 2356 return getPersistence().containsGroup(pk, groupPK); 2357 } 2358 2359 /** 2360 * Returns <code>true</code> if the user has any groups associated with it. 2361 * 2362 * @param pk the primary key of the user to check for associations with groups 2363 * @return <code>true</code> if the user has any groups associated with it; <code>false</code> otherwise 2364 */ 2365 public static boolean containsGroups(long pk) { 2366 return getPersistence().containsGroups(pk); 2367 } 2368 2369 /** 2370 * Adds an association between the user and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2371 * 2372 * @param pk the primary key of the user 2373 * @param groupPK the primary key of the group 2374 */ 2375 public static void addGroup(long pk, long groupPK) { 2376 getPersistence().addGroup(pk, groupPK); 2377 } 2378 2379 /** 2380 * Adds an association between the user and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2381 * 2382 * @param pk the primary key of the user 2383 * @param group the group 2384 */ 2385 public static void addGroup(long pk, com.liferay.portal.model.Group group) { 2386 getPersistence().addGroup(pk, group); 2387 } 2388 2389 /** 2390 * Adds an association between the user and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2391 * 2392 * @param pk the primary key of the user 2393 * @param groupPKs the primary keys of the groups 2394 */ 2395 public static void addGroups(long pk, long[] groupPKs) { 2396 getPersistence().addGroups(pk, groupPKs); 2397 } 2398 2399 /** 2400 * Adds an association between the user and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2401 * 2402 * @param pk the primary key of the user 2403 * @param groups the groups 2404 */ 2405 public static void addGroups(long pk, 2406 List<com.liferay.portal.model.Group> groups) { 2407 getPersistence().addGroups(pk, groups); 2408 } 2409 2410 /** 2411 * Clears all associations between the user and its groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2412 * 2413 * @param pk the primary key of the user to clear the associated groups from 2414 */ 2415 public static void clearGroups(long pk) { 2416 getPersistence().clearGroups(pk); 2417 } 2418 2419 /** 2420 * Removes the association between the user and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2421 * 2422 * @param pk the primary key of the user 2423 * @param groupPK the primary key of the group 2424 */ 2425 public static void removeGroup(long pk, long groupPK) { 2426 getPersistence().removeGroup(pk, groupPK); 2427 } 2428 2429 /** 2430 * Removes the association between the user and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2431 * 2432 * @param pk the primary key of the user 2433 * @param group the group 2434 */ 2435 public static void removeGroup(long pk, com.liferay.portal.model.Group group) { 2436 getPersistence().removeGroup(pk, group); 2437 } 2438 2439 /** 2440 * Removes the association between the user and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2441 * 2442 * @param pk the primary key of the user 2443 * @param groupPKs the primary keys of the groups 2444 */ 2445 public static void removeGroups(long pk, long[] groupPKs) { 2446 getPersistence().removeGroups(pk, groupPKs); 2447 } 2448 2449 /** 2450 * Removes the association between the user and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2451 * 2452 * @param pk the primary key of the user 2453 * @param groups the groups 2454 */ 2455 public static void removeGroups(long pk, 2456 List<com.liferay.portal.model.Group> groups) { 2457 getPersistence().removeGroups(pk, groups); 2458 } 2459 2460 /** 2461 * Sets the groups associated with the user, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2462 * 2463 * @param pk the primary key of the user 2464 * @param groupPKs the primary keys of the groups to be associated with the user 2465 */ 2466 public static void setGroups(long pk, long[] groupPKs) { 2467 getPersistence().setGroups(pk, groupPKs); 2468 } 2469 2470 /** 2471 * Sets the groups associated with the user, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2472 * 2473 * @param pk the primary key of the user 2474 * @param groups the groups to be associated with the user 2475 */ 2476 public static void setGroups(long pk, 2477 List<com.liferay.portal.model.Group> groups) { 2478 getPersistence().setGroups(pk, groups); 2479 } 2480 2481 /** 2482 * Returns the primaryKeys of organizations associated with the user. 2483 * 2484 * @param pk the primary key of the user 2485 * @return long[] of the primaryKeys of organizations associated with the user 2486 */ 2487 public static long[] getOrganizationPrimaryKeys(long pk) { 2488 return getPersistence().getOrganizationPrimaryKeys(pk); 2489 } 2490 2491 /** 2492 * Returns all the organizations associated with the user. 2493 * 2494 * @param pk the primary key of the user 2495 * @return the organizations associated with the user 2496 */ 2497 public static List<com.liferay.portal.model.Organization> getOrganizations( 2498 long pk) { 2499 return getPersistence().getOrganizations(pk); 2500 } 2501 2502 /** 2503 * Returns a range of all the organizations associated with the user. 2504 * 2505 * <p> 2506 * 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 UserModelImpl}. 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. 2507 * </p> 2508 * 2509 * @param pk the primary key of the user 2510 * @param start the lower bound of the range of users 2511 * @param end the upper bound of the range of users (not inclusive) 2512 * @return the range of organizations associated with the user 2513 */ 2514 public static List<com.liferay.portal.model.Organization> getOrganizations( 2515 long pk, int start, int end) { 2516 return getPersistence().getOrganizations(pk, start, end); 2517 } 2518 2519 /** 2520 * Returns an ordered range of all the organizations associated with the user. 2521 * 2522 * <p> 2523 * 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 UserModelImpl}. 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. 2524 * </p> 2525 * 2526 * @param pk the primary key of the user 2527 * @param start the lower bound of the range of users 2528 * @param end the upper bound of the range of users (not inclusive) 2529 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2530 * @return the ordered range of organizations associated with the user 2531 */ 2532 public static List<com.liferay.portal.model.Organization> getOrganizations( 2533 long pk, int start, int end, 2534 OrderByComparator<com.liferay.portal.model.Organization> orderByComparator) { 2535 return getPersistence() 2536 .getOrganizations(pk, start, end, orderByComparator); 2537 } 2538 2539 /** 2540 * Returns the number of organizations associated with the user. 2541 * 2542 * @param pk the primary key of the user 2543 * @return the number of organizations associated with the user 2544 */ 2545 public static int getOrganizationsSize(long pk) { 2546 return getPersistence().getOrganizationsSize(pk); 2547 } 2548 2549 /** 2550 * Returns <code>true</code> if the organization is associated with the user. 2551 * 2552 * @param pk the primary key of the user 2553 * @param organizationPK the primary key of the organization 2554 * @return <code>true</code> if the organization is associated with the user; <code>false</code> otherwise 2555 */ 2556 public static boolean containsOrganization(long pk, long organizationPK) { 2557 return getPersistence().containsOrganization(pk, organizationPK); 2558 } 2559 2560 /** 2561 * Returns <code>true</code> if the user has any organizations associated with it. 2562 * 2563 * @param pk the primary key of the user to check for associations with organizations 2564 * @return <code>true</code> if the user has any organizations associated with it; <code>false</code> otherwise 2565 */ 2566 public static boolean containsOrganizations(long pk) { 2567 return getPersistence().containsOrganizations(pk); 2568 } 2569 2570 /** 2571 * Adds an association between the user and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2572 * 2573 * @param pk the primary key of the user 2574 * @param organizationPK the primary key of the organization 2575 */ 2576 public static void addOrganization(long pk, long organizationPK) { 2577 getPersistence().addOrganization(pk, organizationPK); 2578 } 2579 2580 /** 2581 * Adds an association between the user and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2582 * 2583 * @param pk the primary key of the user 2584 * @param organization the organization 2585 */ 2586 public static void addOrganization(long pk, 2587 com.liferay.portal.model.Organization organization) { 2588 getPersistence().addOrganization(pk, organization); 2589 } 2590 2591 /** 2592 * Adds an association between the user and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2593 * 2594 * @param pk the primary key of the user 2595 * @param organizationPKs the primary keys of the organizations 2596 */ 2597 public static void addOrganizations(long pk, long[] organizationPKs) { 2598 getPersistence().addOrganizations(pk, organizationPKs); 2599 } 2600 2601 /** 2602 * Adds an association between the user and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2603 * 2604 * @param pk the primary key of the user 2605 * @param organizations the organizations 2606 */ 2607 public static void addOrganizations(long pk, 2608 List<com.liferay.portal.model.Organization> organizations) { 2609 getPersistence().addOrganizations(pk, organizations); 2610 } 2611 2612 /** 2613 * Clears all associations between the user and its organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2614 * 2615 * @param pk the primary key of the user to clear the associated organizations from 2616 */ 2617 public static void clearOrganizations(long pk) { 2618 getPersistence().clearOrganizations(pk); 2619 } 2620 2621 /** 2622 * Removes the association between the user and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2623 * 2624 * @param pk the primary key of the user 2625 * @param organizationPK the primary key of the organization 2626 */ 2627 public static void removeOrganization(long pk, long organizationPK) { 2628 getPersistence().removeOrganization(pk, organizationPK); 2629 } 2630 2631 /** 2632 * Removes the association between the user and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2633 * 2634 * @param pk the primary key of the user 2635 * @param organization the organization 2636 */ 2637 public static void removeOrganization(long pk, 2638 com.liferay.portal.model.Organization organization) { 2639 getPersistence().removeOrganization(pk, organization); 2640 } 2641 2642 /** 2643 * Removes the association between the user and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2644 * 2645 * @param pk the primary key of the user 2646 * @param organizationPKs the primary keys of the organizations 2647 */ 2648 public static void removeOrganizations(long pk, long[] organizationPKs) { 2649 getPersistence().removeOrganizations(pk, organizationPKs); 2650 } 2651 2652 /** 2653 * Removes the association between the user and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2654 * 2655 * @param pk the primary key of the user 2656 * @param organizations the organizations 2657 */ 2658 public static void removeOrganizations(long pk, 2659 List<com.liferay.portal.model.Organization> organizations) { 2660 getPersistence().removeOrganizations(pk, organizations); 2661 } 2662 2663 /** 2664 * Sets the organizations associated with the user, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2665 * 2666 * @param pk the primary key of the user 2667 * @param organizationPKs the primary keys of the organizations to be associated with the user 2668 */ 2669 public static void setOrganizations(long pk, long[] organizationPKs) { 2670 getPersistence().setOrganizations(pk, organizationPKs); 2671 } 2672 2673 /** 2674 * Sets the organizations associated with the user, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2675 * 2676 * @param pk the primary key of the user 2677 * @param organizations the organizations to be associated with the user 2678 */ 2679 public static void setOrganizations(long pk, 2680 List<com.liferay.portal.model.Organization> organizations) { 2681 getPersistence().setOrganizations(pk, organizations); 2682 } 2683 2684 /** 2685 * Returns the primaryKeys of roles associated with the user. 2686 * 2687 * @param pk the primary key of the user 2688 * @return long[] of the primaryKeys of roles associated with the user 2689 */ 2690 public static long[] getRolePrimaryKeys(long pk) { 2691 return getPersistence().getRolePrimaryKeys(pk); 2692 } 2693 2694 /** 2695 * Returns all the roles associated with the user. 2696 * 2697 * @param pk the primary key of the user 2698 * @return the roles associated with the user 2699 */ 2700 public static List<com.liferay.portal.model.Role> getRoles(long pk) { 2701 return getPersistence().getRoles(pk); 2702 } 2703 2704 /** 2705 * Returns a range of all the roles associated with the user. 2706 * 2707 * <p> 2708 * 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 UserModelImpl}. 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. 2709 * </p> 2710 * 2711 * @param pk the primary key of the user 2712 * @param start the lower bound of the range of users 2713 * @param end the upper bound of the range of users (not inclusive) 2714 * @return the range of roles associated with the user 2715 */ 2716 public static List<com.liferay.portal.model.Role> getRoles(long pk, 2717 int start, int end) { 2718 return getPersistence().getRoles(pk, start, end); 2719 } 2720 2721 /** 2722 * Returns an ordered range of all the roles associated with the user. 2723 * 2724 * <p> 2725 * 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 UserModelImpl}. 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. 2726 * </p> 2727 * 2728 * @param pk the primary key of the user 2729 * @param start the lower bound of the range of users 2730 * @param end the upper bound of the range of users (not inclusive) 2731 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2732 * @return the ordered range of roles associated with the user 2733 */ 2734 public static List<com.liferay.portal.model.Role> getRoles(long pk, 2735 int start, int end, 2736 OrderByComparator<com.liferay.portal.model.Role> orderByComparator) { 2737 return getPersistence().getRoles(pk, start, end, orderByComparator); 2738 } 2739 2740 /** 2741 * Returns the number of roles associated with the user. 2742 * 2743 * @param pk the primary key of the user 2744 * @return the number of roles associated with the user 2745 */ 2746 public static int getRolesSize(long pk) { 2747 return getPersistence().getRolesSize(pk); 2748 } 2749 2750 /** 2751 * Returns <code>true</code> if the role is associated with the user. 2752 * 2753 * @param pk the primary key of the user 2754 * @param rolePK the primary key of the role 2755 * @return <code>true</code> if the role is associated with the user; <code>false</code> otherwise 2756 */ 2757 public static boolean containsRole(long pk, long rolePK) { 2758 return getPersistence().containsRole(pk, rolePK); 2759 } 2760 2761 /** 2762 * Returns <code>true</code> if the user has any roles associated with it. 2763 * 2764 * @param pk the primary key of the user to check for associations with roles 2765 * @return <code>true</code> if the user has any roles associated with it; <code>false</code> otherwise 2766 */ 2767 public static boolean containsRoles(long pk) { 2768 return getPersistence().containsRoles(pk); 2769 } 2770 2771 /** 2772 * Adds an association between the user and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2773 * 2774 * @param pk the primary key of the user 2775 * @param rolePK the primary key of the role 2776 */ 2777 public static void addRole(long pk, long rolePK) { 2778 getPersistence().addRole(pk, rolePK); 2779 } 2780 2781 /** 2782 * Adds an association between the user and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2783 * 2784 * @param pk the primary key of the user 2785 * @param role the role 2786 */ 2787 public static void addRole(long pk, com.liferay.portal.model.Role role) { 2788 getPersistence().addRole(pk, role); 2789 } 2790 2791 /** 2792 * Adds an association between the user and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2793 * 2794 * @param pk the primary key of the user 2795 * @param rolePKs the primary keys of the roles 2796 */ 2797 public static void addRoles(long pk, long[] rolePKs) { 2798 getPersistence().addRoles(pk, rolePKs); 2799 } 2800 2801 /** 2802 * Adds an association between the user and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2803 * 2804 * @param pk the primary key of the user 2805 * @param roles the roles 2806 */ 2807 public static void addRoles(long pk, 2808 List<com.liferay.portal.model.Role> roles) { 2809 getPersistence().addRoles(pk, roles); 2810 } 2811 2812 /** 2813 * Clears all associations between the user and its roles. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2814 * 2815 * @param pk the primary key of the user to clear the associated roles from 2816 */ 2817 public static void clearRoles(long pk) { 2818 getPersistence().clearRoles(pk); 2819 } 2820 2821 /** 2822 * Removes the association between the user and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2823 * 2824 * @param pk the primary key of the user 2825 * @param rolePK the primary key of the role 2826 */ 2827 public static void removeRole(long pk, long rolePK) { 2828 getPersistence().removeRole(pk, rolePK); 2829 } 2830 2831 /** 2832 * Removes the association between the user and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2833 * 2834 * @param pk the primary key of the user 2835 * @param role the role 2836 */ 2837 public static void removeRole(long pk, com.liferay.portal.model.Role role) { 2838 getPersistence().removeRole(pk, role); 2839 } 2840 2841 /** 2842 * Removes the association between the user and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2843 * 2844 * @param pk the primary key of the user 2845 * @param rolePKs the primary keys of the roles 2846 */ 2847 public static void removeRoles(long pk, long[] rolePKs) { 2848 getPersistence().removeRoles(pk, rolePKs); 2849 } 2850 2851 /** 2852 * Removes the association between the user and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2853 * 2854 * @param pk the primary key of the user 2855 * @param roles the roles 2856 */ 2857 public static void removeRoles(long pk, 2858 List<com.liferay.portal.model.Role> roles) { 2859 getPersistence().removeRoles(pk, roles); 2860 } 2861 2862 /** 2863 * Sets the roles associated with the user, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2864 * 2865 * @param pk the primary key of the user 2866 * @param rolePKs the primary keys of the roles to be associated with the user 2867 */ 2868 public static void setRoles(long pk, long[] rolePKs) { 2869 getPersistence().setRoles(pk, rolePKs); 2870 } 2871 2872 /** 2873 * Sets the roles associated with the user, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2874 * 2875 * @param pk the primary key of the user 2876 * @param roles the roles to be associated with the user 2877 */ 2878 public static void setRoles(long pk, 2879 List<com.liferay.portal.model.Role> roles) { 2880 getPersistence().setRoles(pk, roles); 2881 } 2882 2883 /** 2884 * Returns the primaryKeys of teams associated with the user. 2885 * 2886 * @param pk the primary key of the user 2887 * @return long[] of the primaryKeys of teams associated with the user 2888 */ 2889 public static long[] getTeamPrimaryKeys(long pk) { 2890 return getPersistence().getTeamPrimaryKeys(pk); 2891 } 2892 2893 /** 2894 * Returns all the teams associated with the user. 2895 * 2896 * @param pk the primary key of the user 2897 * @return the teams associated with the user 2898 */ 2899 public static List<com.liferay.portal.model.Team> getTeams(long pk) { 2900 return getPersistence().getTeams(pk); 2901 } 2902 2903 /** 2904 * Returns a range of all the teams associated with the user. 2905 * 2906 * <p> 2907 * 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 UserModelImpl}. 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. 2908 * </p> 2909 * 2910 * @param pk the primary key of the user 2911 * @param start the lower bound of the range of users 2912 * @param end the upper bound of the range of users (not inclusive) 2913 * @return the range of teams associated with the user 2914 */ 2915 public static List<com.liferay.portal.model.Team> getTeams(long pk, 2916 int start, int end) { 2917 return getPersistence().getTeams(pk, start, end); 2918 } 2919 2920 /** 2921 * Returns an ordered range of all the teams associated with the user. 2922 * 2923 * <p> 2924 * 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 UserModelImpl}. 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. 2925 * </p> 2926 * 2927 * @param pk the primary key of the user 2928 * @param start the lower bound of the range of users 2929 * @param end the upper bound of the range of users (not inclusive) 2930 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 2931 * @return the ordered range of teams associated with the user 2932 */ 2933 public static List<com.liferay.portal.model.Team> getTeams(long pk, 2934 int start, int end, 2935 OrderByComparator<com.liferay.portal.model.Team> orderByComparator) { 2936 return getPersistence().getTeams(pk, start, end, orderByComparator); 2937 } 2938 2939 /** 2940 * Returns the number of teams associated with the user. 2941 * 2942 * @param pk the primary key of the user 2943 * @return the number of teams associated with the user 2944 */ 2945 public static int getTeamsSize(long pk) { 2946 return getPersistence().getTeamsSize(pk); 2947 } 2948 2949 /** 2950 * Returns <code>true</code> if the team is associated with the user. 2951 * 2952 * @param pk the primary key of the user 2953 * @param teamPK the primary key of the team 2954 * @return <code>true</code> if the team is associated with the user; <code>false</code> otherwise 2955 */ 2956 public static boolean containsTeam(long pk, long teamPK) { 2957 return getPersistence().containsTeam(pk, teamPK); 2958 } 2959 2960 /** 2961 * Returns <code>true</code> if the user has any teams associated with it. 2962 * 2963 * @param pk the primary key of the user to check for associations with teams 2964 * @return <code>true</code> if the user has any teams associated with it; <code>false</code> otherwise 2965 */ 2966 public static boolean containsTeams(long pk) { 2967 return getPersistence().containsTeams(pk); 2968 } 2969 2970 /** 2971 * Adds an association between the user and the team. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2972 * 2973 * @param pk the primary key of the user 2974 * @param teamPK the primary key of the team 2975 */ 2976 public static void addTeam(long pk, long teamPK) { 2977 getPersistence().addTeam(pk, teamPK); 2978 } 2979 2980 /** 2981 * Adds an association between the user and the team. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2982 * 2983 * @param pk the primary key of the user 2984 * @param team the team 2985 */ 2986 public static void addTeam(long pk, com.liferay.portal.model.Team team) { 2987 getPersistence().addTeam(pk, team); 2988 } 2989 2990 /** 2991 * Adds an association between the user and the teams. Also notifies the appropriate model listeners and clears the mapping table finder cache. 2992 * 2993 * @param pk the primary key of the user 2994 * @param teamPKs the primary keys of the teams 2995 */ 2996 public static void addTeams(long pk, long[] teamPKs) { 2997 getPersistence().addTeams(pk, teamPKs); 2998 } 2999 3000 /** 3001 * Adds an association between the user and the teams. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3002 * 3003 * @param pk the primary key of the user 3004 * @param teams the teams 3005 */ 3006 public static void addTeams(long pk, 3007 List<com.liferay.portal.model.Team> teams) { 3008 getPersistence().addTeams(pk, teams); 3009 } 3010 3011 /** 3012 * Clears all associations between the user and its teams. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3013 * 3014 * @param pk the primary key of the user to clear the associated teams from 3015 */ 3016 public static void clearTeams(long pk) { 3017 getPersistence().clearTeams(pk); 3018 } 3019 3020 /** 3021 * Removes the association between the user and the team. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3022 * 3023 * @param pk the primary key of the user 3024 * @param teamPK the primary key of the team 3025 */ 3026 public static void removeTeam(long pk, long teamPK) { 3027 getPersistence().removeTeam(pk, teamPK); 3028 } 3029 3030 /** 3031 * Removes the association between the user and the team. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3032 * 3033 * @param pk the primary key of the user 3034 * @param team the team 3035 */ 3036 public static void removeTeam(long pk, com.liferay.portal.model.Team team) { 3037 getPersistence().removeTeam(pk, team); 3038 } 3039 3040 /** 3041 * Removes the association between the user and the teams. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3042 * 3043 * @param pk the primary key of the user 3044 * @param teamPKs the primary keys of the teams 3045 */ 3046 public static void removeTeams(long pk, long[] teamPKs) { 3047 getPersistence().removeTeams(pk, teamPKs); 3048 } 3049 3050 /** 3051 * Removes the association between the user and the teams. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3052 * 3053 * @param pk the primary key of the user 3054 * @param teams the teams 3055 */ 3056 public static void removeTeams(long pk, 3057 List<com.liferay.portal.model.Team> teams) { 3058 getPersistence().removeTeams(pk, teams); 3059 } 3060 3061 /** 3062 * Sets the teams associated with the user, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3063 * 3064 * @param pk the primary key of the user 3065 * @param teamPKs the primary keys of the teams to be associated with the user 3066 */ 3067 public static void setTeams(long pk, long[] teamPKs) { 3068 getPersistence().setTeams(pk, teamPKs); 3069 } 3070 3071 /** 3072 * Sets the teams associated with the user, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3073 * 3074 * @param pk the primary key of the user 3075 * @param teams the teams to be associated with the user 3076 */ 3077 public static void setTeams(long pk, 3078 List<com.liferay.portal.model.Team> teams) { 3079 getPersistence().setTeams(pk, teams); 3080 } 3081 3082 /** 3083 * Returns the primaryKeys of user groups associated with the user. 3084 * 3085 * @param pk the primary key of the user 3086 * @return long[] of the primaryKeys of user groups associated with the user 3087 */ 3088 public static long[] getUserGroupPrimaryKeys(long pk) { 3089 return getPersistence().getUserGroupPrimaryKeys(pk); 3090 } 3091 3092 /** 3093 * Returns all the user groups associated with the user. 3094 * 3095 * @param pk the primary key of the user 3096 * @return the user groups associated with the user 3097 */ 3098 public static List<com.liferay.portal.model.UserGroup> getUserGroups( 3099 long pk) { 3100 return getPersistence().getUserGroups(pk); 3101 } 3102 3103 /** 3104 * Returns a range of all the user groups associated with the user. 3105 * 3106 * <p> 3107 * 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 UserModelImpl}. 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. 3108 * </p> 3109 * 3110 * @param pk the primary key of the user 3111 * @param start the lower bound of the range of users 3112 * @param end the upper bound of the range of users (not inclusive) 3113 * @return the range of user groups associated with the user 3114 */ 3115 public static List<com.liferay.portal.model.UserGroup> getUserGroups( 3116 long pk, int start, int end) { 3117 return getPersistence().getUserGroups(pk, start, end); 3118 } 3119 3120 /** 3121 * Returns an ordered range of all the user groups associated with the user. 3122 * 3123 * <p> 3124 * 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 UserModelImpl}. 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. 3125 * </p> 3126 * 3127 * @param pk the primary key of the user 3128 * @param start the lower bound of the range of users 3129 * @param end the upper bound of the range of users (not inclusive) 3130 * @param orderByComparator the comparator to order the results by (optionally <code>null</code>) 3131 * @return the ordered range of user groups associated with the user 3132 */ 3133 public static List<com.liferay.portal.model.UserGroup> getUserGroups( 3134 long pk, int start, int end, 3135 OrderByComparator<com.liferay.portal.model.UserGroup> orderByComparator) { 3136 return getPersistence().getUserGroups(pk, start, end, orderByComparator); 3137 } 3138 3139 /** 3140 * Returns the number of user groups associated with the user. 3141 * 3142 * @param pk the primary key of the user 3143 * @return the number of user groups associated with the user 3144 */ 3145 public static int getUserGroupsSize(long pk) { 3146 return getPersistence().getUserGroupsSize(pk); 3147 } 3148 3149 /** 3150 * Returns <code>true</code> if the user group is associated with the user. 3151 * 3152 * @param pk the primary key of the user 3153 * @param userGroupPK the primary key of the user group 3154 * @return <code>true</code> if the user group is associated with the user; <code>false</code> otherwise 3155 */ 3156 public static boolean containsUserGroup(long pk, long userGroupPK) { 3157 return getPersistence().containsUserGroup(pk, userGroupPK); 3158 } 3159 3160 /** 3161 * Returns <code>true</code> if the user has any user groups associated with it. 3162 * 3163 * @param pk the primary key of the user to check for associations with user groups 3164 * @return <code>true</code> if the user has any user groups associated with it; <code>false</code> otherwise 3165 */ 3166 public static boolean containsUserGroups(long pk) { 3167 return getPersistence().containsUserGroups(pk); 3168 } 3169 3170 /** 3171 * Adds an association between the user and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3172 * 3173 * @param pk the primary key of the user 3174 * @param userGroupPK the primary key of the user group 3175 */ 3176 public static void addUserGroup(long pk, long userGroupPK) { 3177 getPersistence().addUserGroup(pk, userGroupPK); 3178 } 3179 3180 /** 3181 * Adds an association between the user and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3182 * 3183 * @param pk the primary key of the user 3184 * @param userGroup the user group 3185 */ 3186 public static void addUserGroup(long pk, 3187 com.liferay.portal.model.UserGroup userGroup) { 3188 getPersistence().addUserGroup(pk, userGroup); 3189 } 3190 3191 /** 3192 * Adds an association between the user and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3193 * 3194 * @param pk the primary key of the user 3195 * @param userGroupPKs the primary keys of the user groups 3196 */ 3197 public static void addUserGroups(long pk, long[] userGroupPKs) { 3198 getPersistence().addUserGroups(pk, userGroupPKs); 3199 } 3200 3201 /** 3202 * Adds an association between the user and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3203 * 3204 * @param pk the primary key of the user 3205 * @param userGroups the user groups 3206 */ 3207 public static void addUserGroups(long pk, 3208 List<com.liferay.portal.model.UserGroup> userGroups) { 3209 getPersistence().addUserGroups(pk, userGroups); 3210 } 3211 3212 /** 3213 * Clears all associations between the user and its user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3214 * 3215 * @param pk the primary key of the user to clear the associated user groups from 3216 */ 3217 public static void clearUserGroups(long pk) { 3218 getPersistence().clearUserGroups(pk); 3219 } 3220 3221 /** 3222 * Removes the association between the user and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3223 * 3224 * @param pk the primary key of the user 3225 * @param userGroupPK the primary key of the user group 3226 */ 3227 public static void removeUserGroup(long pk, long userGroupPK) { 3228 getPersistence().removeUserGroup(pk, userGroupPK); 3229 } 3230 3231 /** 3232 * Removes the association between the user and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3233 * 3234 * @param pk the primary key of the user 3235 * @param userGroup the user group 3236 */ 3237 public static void removeUserGroup(long pk, 3238 com.liferay.portal.model.UserGroup userGroup) { 3239 getPersistence().removeUserGroup(pk, userGroup); 3240 } 3241 3242 /** 3243 * Removes the association between the user and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3244 * 3245 * @param pk the primary key of the user 3246 * @param userGroupPKs the primary keys of the user groups 3247 */ 3248 public static void removeUserGroups(long pk, long[] userGroupPKs) { 3249 getPersistence().removeUserGroups(pk, userGroupPKs); 3250 } 3251 3252 /** 3253 * Removes the association between the user and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3254 * 3255 * @param pk the primary key of the user 3256 * @param userGroups the user groups 3257 */ 3258 public static void removeUserGroups(long pk, 3259 List<com.liferay.portal.model.UserGroup> userGroups) { 3260 getPersistence().removeUserGroups(pk, userGroups); 3261 } 3262 3263 /** 3264 * Sets the user groups associated with the user, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3265 * 3266 * @param pk the primary key of the user 3267 * @param userGroupPKs the primary keys of the user groups to be associated with the user 3268 */ 3269 public static void setUserGroups(long pk, long[] userGroupPKs) { 3270 getPersistence().setUserGroups(pk, userGroupPKs); 3271 } 3272 3273 /** 3274 * Sets the user groups associated with the user, removing and adding associations as necessary. Also notifies the appropriate model listeners and clears the mapping table finder cache. 3275 * 3276 * @param pk the primary key of the user 3277 * @param userGroups the user groups to be associated with the user 3278 */ 3279 public static void setUserGroups(long pk, 3280 List<com.liferay.portal.model.UserGroup> userGroups) { 3281 getPersistence().setUserGroups(pk, userGroups); 3282 } 3283 3284 public static java.util.Set<java.lang.String> getBadColumnNames() { 3285 return getPersistence().getBadColumnNames(); 3286 } 3287 3288 public static UserPersistence getPersistence() { 3289 if (_persistence == null) { 3290 _persistence = (UserPersistence)PortalBeanLocatorUtil.locate(UserPersistence.class.getName()); 3291 3292 ReferenceRegistry.registerReference(UserUtil.class, "_persistence"); 3293 } 3294 3295 return _persistence; 3296 } 3297 3298 private static UserPersistence _persistence; 3299 }