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