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