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