Liferay 7.0-ce-b4

com.liferay.portal.service.persistence
Class UserUtil

java.lang.Object
  extended by com.liferay.portal.service.persistence.UserUtil

@ProviderType
public class UserUtil
extends Object

The persistence utility for the user service. This utility wraps UserPersistenceImpl and provides direct access to the database for CRUD operations. This utility should only be used by the service layer, as it must operate within a transaction. Never access this utility in a JSP, controller, model, or other front-end class.

Caching information and settings can be found in portal.properties

See Also:
UserPersistence, UserPersistenceImpl

Constructor Summary
UserUtil()
           
 
Method Summary
static void addGroup(long pk, Group group)
          Adds an association between the user and the group.
static void addGroup(long pk, long groupPK)
          Adds an association between the user and the group.
static void addGroups(long pk, List<Group> groups)
          Adds an association between the user and the groups.
static void addGroups(long pk, long[] groupPKs)
          Adds an association between the user and the groups.
static void addOrganization(long pk, long organizationPK)
          Adds an association between the user and the organization.
static void addOrganization(long pk, Organization organization)
          Adds an association between the user and the organization.
static void addOrganizations(long pk, List<Organization> organizations)
          Adds an association between the user and the organizations.
static void addOrganizations(long pk, long[] organizationPKs)
          Adds an association between the user and the organizations.
static void addRole(long pk, long rolePK)
          Adds an association between the user and the role.
static void addRole(long pk, Role role)
          Adds an association between the user and the role.
static void addRoles(long pk, List<Role> roles)
          Adds an association between the user and the roles.
static void addRoles(long pk, long[] rolePKs)
          Adds an association between the user and the roles.
static void addTeam(long pk, long teamPK)
          Adds an association between the user and the team.
static void addTeam(long pk, Team team)
          Adds an association between the user and the team.
static void addTeams(long pk, List<Team> teams)
          Adds an association between the user and the teams.
static void addTeams(long pk, long[] teamPKs)
          Adds an association between the user and the teams.
static void addUserGroup(long pk, long userGroupPK)
          Adds an association between the user and the user group.
static void addUserGroup(long pk, UserGroup userGroup)
          Adds an association between the user and the user group.
static void addUserGroups(long pk, List<UserGroup> userGroups)
          Adds an association between the user and the user groups.
static void addUserGroups(long pk, long[] userGroupPKs)
          Adds an association between the user and the user groups.
static void cacheResult(List<User> users)
          Caches the users in the entity cache if it is enabled.
static void cacheResult(User user)
          Caches the user in the entity cache if it is enabled.
static void clearCache()
           
static void clearCache(User user)
           
static void clearGroups(long pk)
          Clears all associations between the user and its groups.
static void clearOrganizations(long pk)
          Clears all associations between the user and its organizations.
static void clearRoles(long pk)
          Clears all associations between the user and its roles.
static void clearTeams(long pk)
          Clears all associations between the user and its teams.
static void clearUserGroups(long pk)
          Clears all associations between the user and its user groups.
static boolean containsGroup(long pk, long groupPK)
          Returns true if the group is associated with the user.
static boolean containsGroups(long pk)
          Returns true if the user has any groups associated with it.
static boolean containsOrganization(long pk, long organizationPK)
          Returns true if the organization is associated with the user.
static boolean containsOrganizations(long pk)
          Returns true if the user has any organizations associated with it.
static boolean containsRole(long pk, long rolePK)
          Returns true if the role is associated with the user.
static boolean containsRoles(long pk)
          Returns true if the user has any roles associated with it.
static boolean containsTeam(long pk, long teamPK)
          Returns true if the team is associated with the user.
static boolean containsTeams(long pk)
          Returns true if the user has any teams associated with it.
static boolean containsUserGroup(long pk, long userGroupPK)
          Returns true if the user group is associated with the user.
static boolean containsUserGroups(long pk)
          Returns true if the user has any user groups associated with it.
static int countAll()
          Returns the number of users.
static int countByC_CD_MD(long companyId, Date createDate, Date modifiedDate)
          Returns the number of users where companyId = ? and createDate = ? and modifiedDate = ?.
static int countByC_CD(long companyId, Date createDate)
          Returns the number of users where companyId = ? and createDate = ?.
static int countByC_DU_S(long companyId, boolean defaultUser, int status)
          Returns the number of users where companyId = ? and defaultUser = ? and status = ?.
static int countByC_DU(long companyId, boolean defaultUser)
          Returns the number of users where companyId = ? and defaultUser = ?.
static int countByC_EA(long companyId, String emailAddress)
          Returns the number of users where companyId = ? and emailAddress = ?.
static int countByC_FID(long companyId, long facebookId)
          Returns the number of users where companyId = ? and facebookId = ?.
static int countByC_MD(long companyId, Date modifiedDate)
          Returns the number of users where companyId = ? and modifiedDate = ?.
static int countByC_O(long companyId, String openId)
          Returns the number of users where companyId = ? and openId = ?.
static int countByC_S(long companyId, int status)
          Returns the number of users where companyId = ? and status = ?.
static int countByC_SN(long companyId, String screenName)
          Returns the number of users where companyId = ? and screenName = ?.
static int countByC_U(long companyId, long userId)
          Returns the number of users where companyId = ? and userId = ?.
static int countByCompanyId(long companyId)
          Returns the number of users where companyId = ?.
static int countByContactId(long contactId)
          Returns the number of users where contactId = ?.
static int countByEmailAddress(String emailAddress)
          Returns the number of users where emailAddress = ?.
static int countByPortraitId(long portraitId)
          Returns the number of users where portraitId = ?.
static int countByUuid_C(String uuid, long companyId)
          Returns the number of users where uuid = ? and companyId = ?.
static int countByUuid(String uuid)
          Returns the number of users where uuid = ?.
static long countWithDynamicQuery(DynamicQuery dynamicQuery)
           
static User create(long userId)
          Creates a new user with the primary key.
static User fetchByC_CD_First(long companyId, Date createDate, OrderByComparator<User> orderByComparator)
          Returns the first user in the ordered set where companyId = ? and createDate = ?.
static User fetchByC_CD_Last(long companyId, Date createDate, OrderByComparator<User> orderByComparator)
          Returns the last user in the ordered set where companyId = ? and createDate = ?.
static User fetchByC_CD_MD_First(long companyId, Date createDate, Date modifiedDate, OrderByComparator<User> orderByComparator)
          Returns the first user in the ordered set where companyId = ? and createDate = ? and modifiedDate = ?.
static User fetchByC_CD_MD_Last(long companyId, Date createDate, Date modifiedDate, OrderByComparator<User> orderByComparator)
          Returns the last user in the ordered set where companyId = ? and createDate = ? and modifiedDate = ?.
static User fetchByC_DU_S_First(long companyId, boolean defaultUser, int status, OrderByComparator<User> orderByComparator)
          Returns the first user in the ordered set where companyId = ? and defaultUser = ? and status = ?.
static User fetchByC_DU_S_Last(long companyId, boolean defaultUser, int status, OrderByComparator<User> orderByComparator)
          Returns the last user in the ordered set where companyId = ? and defaultUser = ? and status = ?.
static User fetchByC_DU(long companyId, boolean defaultUser)
          Returns the user where companyId = ? and defaultUser = ? or returns null if it could not be found.
static User fetchByC_DU(long companyId, boolean defaultUser, boolean retrieveFromCache)
          Returns the user where companyId = ? and defaultUser = ? or returns null if it could not be found, optionally using the finder cache.
static User fetchByC_EA(long companyId, String emailAddress)
          Returns the user where companyId = ? and emailAddress = ? or returns null if it could not be found.
static User fetchByC_EA(long companyId, String emailAddress, boolean retrieveFromCache)
          Returns the user where companyId = ? and emailAddress = ? or returns null if it could not be found, optionally using the finder cache.
static User fetchByC_FID(long companyId, long facebookId)
          Returns the user where companyId = ? and facebookId = ? or returns null if it could not be found.
static User fetchByC_FID(long companyId, long facebookId, boolean retrieveFromCache)
          Returns the user where companyId = ? and facebookId = ? or returns null if it could not be found, optionally using the finder cache.
static User fetchByC_MD_First(long companyId, Date modifiedDate, OrderByComparator<User> orderByComparator)
          Returns the first user in the ordered set where companyId = ? and modifiedDate = ?.
static User fetchByC_MD_Last(long companyId, Date modifiedDate, OrderByComparator<User> orderByComparator)
          Returns the last user in the ordered set where companyId = ? and modifiedDate = ?.
static User fetchByC_O(long companyId, String openId)
          Returns the user where companyId = ? and openId = ? or returns null if it could not be found.
static User fetchByC_O(long companyId, String openId, boolean retrieveFromCache)
          Returns the user where companyId = ? and openId = ? or returns null if it could not be found, optionally using the finder cache.
static User fetchByC_S_First(long companyId, int status, OrderByComparator<User> orderByComparator)
          Returns the first user in the ordered set where companyId = ? and status = ?.
static User fetchByC_S_Last(long companyId, int status, OrderByComparator<User> orderByComparator)
          Returns the last user in the ordered set where companyId = ? and status = ?.
static User fetchByC_SN(long companyId, String screenName)
          Returns the user where companyId = ? and screenName = ? or returns null if it could not be found.
static User fetchByC_SN(long companyId, String screenName, boolean retrieveFromCache)
          Returns the user where companyId = ? and screenName = ? or returns null if it could not be found, optionally using the finder cache.
static User fetchByC_U(long companyId, long userId)
          Returns the user where companyId = ? and userId = ? or returns null if it could not be found.
static User fetchByC_U(long companyId, long userId, boolean retrieveFromCache)
          Returns the user where companyId = ? and userId = ? or returns null if it could not be found, optionally using the finder cache.
static User fetchByCompanyId_First(long companyId, OrderByComparator<User> orderByComparator)
          Returns the first user in the ordered set where companyId = ?.
static User fetchByCompanyId_Last(long companyId, OrderByComparator<User> orderByComparator)
          Returns the last user in the ordered set where companyId = ?.
static User fetchByContactId(long contactId)
          Returns the user where contactId = ? or returns null if it could not be found.
static User fetchByContactId(long contactId, boolean retrieveFromCache)
          Returns the user where contactId = ? or returns null if it could not be found, optionally using the finder cache.
static User fetchByEmailAddress_First(String emailAddress, OrderByComparator<User> orderByComparator)
          Returns the first user in the ordered set where emailAddress = ?.
static User fetchByEmailAddress_Last(String emailAddress, OrderByComparator<User> orderByComparator)
          Returns the last user in the ordered set where emailAddress = ?.
static User fetchByPortraitId(long portraitId)
          Returns the user where portraitId = ? or returns null if it could not be found.
static User fetchByPortraitId(long portraitId, boolean retrieveFromCache)
          Returns the user where portraitId = ? or returns null if it could not be found, optionally using the finder cache.
static User fetchByPrimaryKey(long userId)
          Returns the user with the primary key or returns null if it could not be found.
static Map<Serializable,User> fetchByPrimaryKeys(Set<Serializable> primaryKeys)
           
static User fetchByUuid_C_First(String uuid, long companyId, OrderByComparator<User> orderByComparator)
          Returns the first user in the ordered set where uuid = ? and companyId = ?.
static User fetchByUuid_C_Last(String uuid, long companyId, OrderByComparator<User> orderByComparator)
          Returns the last user in the ordered set where uuid = ? and companyId = ?.
static User fetchByUuid_First(String uuid, OrderByComparator<User> orderByComparator)
          Returns the first user in the ordered set where uuid = ?.
static User fetchByUuid_Last(String uuid, OrderByComparator<User> orderByComparator)
          Returns the last user in the ordered set where uuid = ?.
static List<User> findAll()
          Returns all the users.
static List<User> findAll(int start, int end)
          Returns a range of all the users.
static List<User> findAll(int start, int end, OrderByComparator<User> orderByComparator)
          Returns an ordered range of all the users.
static List<User> findAll(int start, int end, OrderByComparator<User> orderByComparator, boolean retrieveFromCache)
          Returns an ordered range of all the users.
static User findByC_CD_First(long companyId, Date createDate, OrderByComparator<User> orderByComparator)
          Returns the first user in the ordered set where companyId = ? and createDate = ?.
static User findByC_CD_Last(long companyId, Date createDate, OrderByComparator<User> orderByComparator)
          Returns the last user in the ordered set where companyId = ? and createDate = ?.
static User findByC_CD_MD_First(long companyId, Date createDate, Date modifiedDate, OrderByComparator<User> orderByComparator)
          Returns the first user in the ordered set where companyId = ? and createDate = ? and modifiedDate = ?.
static User findByC_CD_MD_Last(long companyId, Date createDate, Date modifiedDate, OrderByComparator<User> orderByComparator)
          Returns the last user in the ordered set where companyId = ? and createDate = ? and modifiedDate = ?.
static User[] findByC_CD_MD_PrevAndNext(long userId, long companyId, Date createDate, Date modifiedDate, OrderByComparator<User> orderByComparator)
          Returns the users before and after the current user in the ordered set where companyId = ? and createDate = ? and modifiedDate = ?.
static List<User> findByC_CD_MD(long companyId, Date createDate, Date modifiedDate)
          Returns all the users where companyId = ? and createDate = ? and modifiedDate = ?.
static List<User> findByC_CD_MD(long companyId, Date createDate, Date modifiedDate, int start, int end)
          Returns a range of all the users where companyId = ? and createDate = ? and modifiedDate = ?.
static List<User> findByC_CD_MD(long companyId, Date createDate, Date modifiedDate, int start, int end, OrderByComparator<User> orderByComparator)
          Returns an ordered range of all the users where companyId = ? and createDate = ? and modifiedDate = ?.
static List<User> findByC_CD_MD(long companyId, Date createDate, Date modifiedDate, int start, int end, OrderByComparator<User> orderByComparator, boolean retrieveFromCache)
          Returns an ordered range of all the users where companyId = ? and createDate = ? and modifiedDate = ?.
static User[] findByC_CD_PrevAndNext(long userId, long companyId, Date createDate, OrderByComparator<User> orderByComparator)
          Returns the users before and after the current user in the ordered set where companyId = ? and createDate = ?.
static List<User> findByC_CD(long companyId, Date createDate)
          Returns all the users where companyId = ? and createDate = ?.
static List<User> findByC_CD(long companyId, Date createDate, int start, int end)
          Returns a range of all the users where companyId = ? and createDate = ?.
static List<User> findByC_CD(long companyId, Date createDate, int start, int end, OrderByComparator<User> orderByComparator)
          Returns an ordered range of all the users where companyId = ? and createDate = ?.
static List<User> findByC_CD(long companyId, Date createDate, int start, int end, OrderByComparator<User> orderByComparator, boolean retrieveFromCache)
          Returns an ordered range of all the users where companyId = ? and createDate = ?.
static User findByC_DU_S_First(long companyId, boolean defaultUser, int status, OrderByComparator<User> orderByComparator)
          Returns the first user in the ordered set where companyId = ? and defaultUser = ? and status = ?.
static User findByC_DU_S_Last(long companyId, boolean defaultUser, int status, OrderByComparator<User> orderByComparator)
          Returns the last user in the ordered set where companyId = ? and defaultUser = ? and status = ?.
static User[] findByC_DU_S_PrevAndNext(long userId, long companyId, boolean defaultUser, int status, OrderByComparator<User> orderByComparator)
          Returns the users before and after the current user in the ordered set where companyId = ? and defaultUser = ? and status = ?.
static List<User> findByC_DU_S(long companyId, boolean defaultUser, int status)
          Returns all the users where companyId = ? and defaultUser = ? and status = ?.
static List<User> findByC_DU_S(long companyId, boolean defaultUser, int status, int start, int end)
          Returns a range of all the users where companyId = ? and defaultUser = ? and status = ?.
static List<User> findByC_DU_S(long companyId, boolean defaultUser, int status, int start, int end, OrderByComparator<User> orderByComparator)
          Returns an ordered range of all the users where companyId = ? and defaultUser = ? and status = ?.
static List<User> findByC_DU_S(long companyId, boolean defaultUser, int status, int start, int end, OrderByComparator<User> orderByComparator, boolean retrieveFromCache)
          Returns an ordered range of all the users where companyId = ? and defaultUser = ? and status = ?.
static User findByC_DU(long companyId, boolean defaultUser)
          Returns the user where companyId = ? and defaultUser = ? or throws a NoSuchUserException if it could not be found.
static User findByC_EA(long companyId, String emailAddress)
          Returns the user where companyId = ? and emailAddress = ? or throws a NoSuchUserException if it could not be found.
static User findByC_FID(long companyId, long facebookId)
          Returns the user where companyId = ? and facebookId = ? or throws a NoSuchUserException if it could not be found.
static User findByC_MD_First(long companyId, Date modifiedDate, OrderByComparator<User> orderByComparator)
          Returns the first user in the ordered set where companyId = ? and modifiedDate = ?.
static User findByC_MD_Last(long companyId, Date modifiedDate, OrderByComparator<User> orderByComparator)
          Returns the last user in the ordered set where companyId = ? and modifiedDate = ?.
static User[] findByC_MD_PrevAndNext(long userId, long companyId, Date modifiedDate, OrderByComparator<User> orderByComparator)
          Returns the users before and after the current user in the ordered set where companyId = ? and modifiedDate = ?.
static List<User> findByC_MD(long companyId, Date modifiedDate)
          Returns all the users where companyId = ? and modifiedDate = ?.
static List<User> findByC_MD(long companyId, Date modifiedDate, int start, int end)
          Returns a range of all the users where companyId = ? and modifiedDate = ?.
static List<User> findByC_MD(long companyId, Date modifiedDate, int start, int end, OrderByComparator<User> orderByComparator)
          Returns an ordered range of all the users where companyId = ? and modifiedDate = ?.
static List<User> findByC_MD(long companyId, Date modifiedDate, int start, int end, OrderByComparator<User> orderByComparator, boolean retrieveFromCache)
          Returns an ordered range of all the users where companyId = ? and modifiedDate = ?.
static User findByC_O(long companyId, String openId)
          Returns the user where companyId = ? and openId = ? or throws a NoSuchUserException if it could not be found.
static User findByC_S_First(long companyId, int status, OrderByComparator<User> orderByComparator)
          Returns the first user in the ordered set where companyId = ? and status = ?.
static User findByC_S_Last(long companyId, int status, OrderByComparator<User> orderByComparator)
          Returns the last user in the ordered set where companyId = ? and status = ?.
static User[] findByC_S_PrevAndNext(long userId, long companyId, int status, OrderByComparator<User> orderByComparator)
          Returns the users before and after the current user in the ordered set where companyId = ? and status = ?.
static List<User> findByC_S(long companyId, int status)
          Returns all the users where companyId = ? and status = ?.
static List<User> findByC_S(long companyId, int status, int start, int end)
          Returns a range of all the users where companyId = ? and status = ?.
static List<User> findByC_S(long companyId, int status, int start, int end, OrderByComparator<User> orderByComparator)
          Returns an ordered range of all the users where companyId = ? and status = ?.
static List<User> findByC_S(long companyId, int status, int start, int end, OrderByComparator<User> orderByComparator, boolean retrieveFromCache)
          Returns an ordered range of all the users where companyId = ? and status = ?.
static User findByC_SN(long companyId, String screenName)
          Returns the user where companyId = ? and screenName = ? or throws a NoSuchUserException if it could not be found.
static User findByC_U(long companyId, long userId)
          Returns the user where companyId = ? and userId = ? or throws a NoSuchUserException if it could not be found.
static User findByCompanyId_First(long companyId, OrderByComparator<User> orderByComparator)
          Returns the first user in the ordered set where companyId = ?.
static User findByCompanyId_Last(long companyId, OrderByComparator<User> orderByComparator)
          Returns the last user in the ordered set where companyId = ?.
static User[] findByCompanyId_PrevAndNext(long userId, long companyId, OrderByComparator<User> orderByComparator)
          Returns the users before and after the current user in the ordered set where companyId = ?.
static List<User> findByCompanyId(long companyId)
          Returns all the users where companyId = ?.
static List<User> findByCompanyId(long companyId, int start, int end)
          Returns a range of all the users where companyId = ?.
static List<User> findByCompanyId(long companyId, int start, int end, OrderByComparator<User> orderByComparator)
          Returns an ordered range of all the users where companyId = ?.
static List<User> findByCompanyId(long companyId, int start, int end, OrderByComparator<User> orderByComparator, boolean retrieveFromCache)
          Returns an ordered range of all the users where companyId = ?.
static User findByContactId(long contactId)
          Returns the user where contactId = ? or throws a NoSuchUserException if it could not be found.
static User findByEmailAddress_First(String emailAddress, OrderByComparator<User> orderByComparator)
          Returns the first user in the ordered set where emailAddress = ?.
static User findByEmailAddress_Last(String emailAddress, OrderByComparator<User> orderByComparator)
          Returns the last user in the ordered set where emailAddress = ?.
static User[] findByEmailAddress_PrevAndNext(long userId, String emailAddress, OrderByComparator<User> orderByComparator)
          Returns the users before and after the current user in the ordered set where emailAddress = ?.
static List<User> findByEmailAddress(String emailAddress)
          Returns all the users where emailAddress = ?.
static List<User> findByEmailAddress(String emailAddress, int start, int end)
          Returns a range of all the users where emailAddress = ?.
static List<User> findByEmailAddress(String emailAddress, int start, int end, OrderByComparator<User> orderByComparator)
          Returns an ordered range of all the users where emailAddress = ?.
static List<User> findByEmailAddress(String emailAddress, int start, int end, OrderByComparator<User> orderByComparator, boolean retrieveFromCache)
          Returns an ordered range of all the users where emailAddress = ?.
static User findByPortraitId(long portraitId)
          Returns the user where portraitId = ? or throws a NoSuchUserException if it could not be found.
static User findByPrimaryKey(long userId)
          Returns the user with the primary key or throws a NoSuchUserException if it could not be found.
static User findByUuid_C_First(String uuid, long companyId, OrderByComparator<User> orderByComparator)
          Returns the first user in the ordered set where uuid = ? and companyId = ?.
static User findByUuid_C_Last(String uuid, long companyId, OrderByComparator<User> orderByComparator)
          Returns the last user in the ordered set where uuid = ? and companyId = ?.
static User[] findByUuid_C_PrevAndNext(long userId, String uuid, long companyId, OrderByComparator<User> orderByComparator)
          Returns the users before and after the current user in the ordered set where uuid = ? and companyId = ?.
static List<User> findByUuid_C(String uuid, long companyId)
          Returns all the users where uuid = ? and companyId = ?.
static List<User> findByUuid_C(String uuid, long companyId, int start, int end)
          Returns a range of all the users where uuid = ? and companyId = ?.
static List<User> findByUuid_C(String uuid, long companyId, int start, int end, OrderByComparator<User> orderByComparator)
          Returns an ordered range of all the users where uuid = ? and companyId = ?.
static List<User> findByUuid_C(String uuid, long companyId, int start, int end, OrderByComparator<User> orderByComparator, boolean retrieveFromCache)
          Returns an ordered range of all the users where uuid = ? and companyId = ?.
static User findByUuid_First(String uuid, OrderByComparator<User> orderByComparator)
          Returns the first user in the ordered set where uuid = ?.
static User findByUuid_Last(String uuid, OrderByComparator<User> orderByComparator)
          Returns the last user in the ordered set where uuid = ?.
static User[] findByUuid_PrevAndNext(long userId, String uuid, OrderByComparator<User> orderByComparator)
          Returns the users before and after the current user in the ordered set where uuid = ?.
static List<User> findByUuid(String uuid)
          Returns all the users where uuid = ?.
static List<User> findByUuid(String uuid, int start, int end)
          Returns a range of all the users where uuid = ?.
static List<User> findByUuid(String uuid, int start, int end, OrderByComparator<User> orderByComparator)
          Returns an ordered range of all the users where uuid = ?.
static List<User> findByUuid(String uuid, int start, int end, OrderByComparator<User> orderByComparator, boolean retrieveFromCache)
          Returns an ordered range of all the users where uuid = ?.
static List<User> findWithDynamicQuery(DynamicQuery dynamicQuery)
           
static List<User> findWithDynamicQuery(DynamicQuery dynamicQuery, int start, int end)
           
static List<User> findWithDynamicQuery(DynamicQuery dynamicQuery, int start, int end, OrderByComparator<User> orderByComparator)
           
static Set<String> getBadColumnNames()
           
static long[] getGroupPrimaryKeys(long pk)
          Returns the primaryKeys of groups associated with the user.
static List<Group> getGroups(long pk)
          Returns all the groups associated with the user.
static List<Group> getGroups(long pk, int start, int end)
          Returns a range of all the groups associated with the user.
static List<Group> getGroups(long pk, int start, int end, OrderByComparator<Group> orderByComparator)
          Returns an ordered range of all the groups associated with the user.
static int getGroupsSize(long pk)
          Returns the number of groups associated with the user.
static long[] getOrganizationPrimaryKeys(long pk)
          Returns the primaryKeys of organizations associated with the user.
static List<Organization> getOrganizations(long pk)
          Returns all the organizations associated with the user.
static List<Organization> getOrganizations(long pk, int start, int end)
          Returns a range of all the organizations associated with the user.
static List<Organization> getOrganizations(long pk, int start, int end, OrderByComparator<Organization> orderByComparator)
          Returns an ordered range of all the organizations associated with the user.
static int getOrganizationsSize(long pk)
          Returns the number of organizations associated with the user.
static UserPersistence getPersistence()
           
static long[] getRolePrimaryKeys(long pk)
          Returns the primaryKeys of roles associated with the user.
static List<Role> getRoles(long pk)
          Returns all the roles associated with the user.
static List<Role> getRoles(long pk, int start, int end)
          Returns a range of all the roles associated with the user.
static List<Role> getRoles(long pk, int start, int end, OrderByComparator<Role> orderByComparator)
          Returns an ordered range of all the roles associated with the user.
static int getRolesSize(long pk)
          Returns the number of roles associated with the user.
static long[] getTeamPrimaryKeys(long pk)
          Returns the primaryKeys of teams associated with the user.
static List<Team> getTeams(long pk)
          Returns all the teams associated with the user.
static List<Team> getTeams(long pk, int start, int end)
          Returns a range of all the teams associated with the user.
static List<Team> getTeams(long pk, int start, int end, OrderByComparator<Team> orderByComparator)
          Returns an ordered range of all the teams associated with the user.
static int getTeamsSize(long pk)
          Returns the number of teams associated with the user.
static long[] getUserGroupPrimaryKeys(long pk)
          Returns the primaryKeys of user groups associated with the user.
static List<UserGroup> getUserGroups(long pk)
          Returns all the user groups associated with the user.
static List<UserGroup> getUserGroups(long pk, int start, int end)
          Returns a range of all the user groups associated with the user.
static List<UserGroup> getUserGroups(long pk, int start, int end, OrderByComparator<UserGroup> orderByComparator)
          Returns an ordered range of all the user groups associated with the user.
static int getUserGroupsSize(long pk)
          Returns the number of user groups associated with the user.
static User remove(long userId)
          Removes the user with the primary key from the database.
static void removeAll()
          Removes all the users from the database.
static void removeByC_CD_MD(long companyId, Date createDate, Date modifiedDate)
          Removes all the users where companyId = ? and createDate = ? and modifiedDate = ? from the database.
static void removeByC_CD(long companyId, Date createDate)
          Removes all the users where companyId = ? and createDate = ? from the database.
static void removeByC_DU_S(long companyId, boolean defaultUser, int status)
          Removes all the users where companyId = ? and defaultUser = ? and status = ? from the database.
static User removeByC_DU(long companyId, boolean defaultUser)
          Removes the user where companyId = ? and defaultUser = ? from the database.
static User removeByC_EA(long companyId, String emailAddress)
          Removes the user where companyId = ? and emailAddress = ? from the database.
static User removeByC_FID(long companyId, long facebookId)
          Removes the user where companyId = ? and facebookId = ? from the database.
static void removeByC_MD(long companyId, Date modifiedDate)
          Removes all the users where companyId = ? and modifiedDate = ? from the database.
static User removeByC_O(long companyId, String openId)
          Removes the user where companyId = ? and openId = ? from the database.
static void removeByC_S(long companyId, int status)
          Removes all the users where companyId = ? and status = ? from the database.
static User removeByC_SN(long companyId, String screenName)
          Removes the user where companyId = ? and screenName = ? from the database.
static User removeByC_U(long companyId, long userId)
          Removes the user where companyId = ? and userId = ? from the database.
static void removeByCompanyId(long companyId)
          Removes all the users where companyId = ? from the database.
static User removeByContactId(long contactId)
          Removes the user where contactId = ? from the database.
static void removeByEmailAddress(String emailAddress)
          Removes all the users where emailAddress = ? from the database.
static User removeByPortraitId(long portraitId)
          Removes the user where portraitId = ? from the database.
static void removeByUuid_C(String uuid, long companyId)
          Removes all the users where uuid = ? and companyId = ? from the database.
static void removeByUuid(String uuid)
          Removes all the users where uuid = ? from the database.
static void removeGroup(long pk, Group group)
          Removes the association between the user and the group.
static void removeGroup(long pk, long groupPK)
          Removes the association between the user and the group.
static void removeGroups(long pk, List<Group> groups)
          Removes the association between the user and the groups.
static void removeGroups(long pk, long[] groupPKs)
          Removes the association between the user and the groups.
static void removeOrganization(long pk, long organizationPK)
          Removes the association between the user and the organization.
static void removeOrganization(long pk, Organization organization)
          Removes the association between the user and the organization.
static void removeOrganizations(long pk, List<Organization> organizations)
          Removes the association between the user and the organizations.
static void removeOrganizations(long pk, long[] organizationPKs)
          Removes the association between the user and the organizations.
static void removeRole(long pk, long rolePK)
          Removes the association between the user and the role.
static void removeRole(long pk, Role role)
          Removes the association between the user and the role.
static void removeRoles(long pk, List<Role> roles)
          Removes the association between the user and the roles.
static void removeRoles(long pk, long[] rolePKs)
          Removes the association between the user and the roles.
static void removeTeam(long pk, long teamPK)
          Removes the association between the user and the team.
static void removeTeam(long pk, Team team)
          Removes the association between the user and the team.
static void removeTeams(long pk, List<Team> teams)
          Removes the association between the user and the teams.
static void removeTeams(long pk, long[] teamPKs)
          Removes the association between the user and the teams.
static void removeUserGroup(long pk, long userGroupPK)
          Removes the association between the user and the user group.
static void removeUserGroup(long pk, UserGroup userGroup)
          Removes the association between the user and the user group.
static void removeUserGroups(long pk, List<UserGroup> userGroups)
          Removes the association between the user and the user groups.
static void removeUserGroups(long pk, long[] userGroupPKs)
          Removes the association between the user and the user groups.
static void setGroups(long pk, List<Group> groups)
          Sets the groups associated with the user, removing and adding associations as necessary.
static void setGroups(long pk, long[] groupPKs)
          Sets the groups associated with the user, removing and adding associations as necessary.
static void setOrganizations(long pk, List<Organization> organizations)
          Sets the organizations associated with the user, removing and adding associations as necessary.
static void setOrganizations(long pk, long[] organizationPKs)
          Sets the organizations associated with the user, removing and adding associations as necessary.
static void setRoles(long pk, List<Role> roles)
          Sets the roles associated with the user, removing and adding associations as necessary.
static void setRoles(long pk, long[] rolePKs)
          Sets the roles associated with the user, removing and adding associations as necessary.
static void setTeams(long pk, List<Team> teams)
          Sets the teams associated with the user, removing and adding associations as necessary.
static void setTeams(long pk, long[] teamPKs)
          Sets the teams associated with the user, removing and adding associations as necessary.
static void setUserGroups(long pk, List<UserGroup> userGroups)
          Sets the user groups associated with the user, removing and adding associations as necessary.
static void setUserGroups(long pk, long[] userGroupPKs)
          Sets the user groups associated with the user, removing and adding associations as necessary.
static User update(User user)
           
static User update(User user, ServiceContext serviceContext)
           
static User updateImpl(User user)
           
 
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
 

Constructor Detail

UserUtil

public UserUtil()
Method Detail

clearCache

public static void clearCache()
See Also:
BasePersistence.clearCache()

clearCache

public static void clearCache(User user)
See Also:
BasePersistence.clearCache(com.liferay.portal.model.BaseModel)

countWithDynamicQuery

public static long countWithDynamicQuery(DynamicQuery dynamicQuery)
See Also:
BasePersistence.countWithDynamicQuery(DynamicQuery)

findWithDynamicQuery

public static List<User> findWithDynamicQuery(DynamicQuery dynamicQuery)
See Also:
BasePersistence.findWithDynamicQuery(DynamicQuery)

findWithDynamicQuery

public static List<User> findWithDynamicQuery(DynamicQuery dynamicQuery,
                                              int start,
                                              int end)
See Also:
BasePersistence.findWithDynamicQuery(DynamicQuery, int, int)

findWithDynamicQuery

public static List<User> findWithDynamicQuery(DynamicQuery dynamicQuery,
                                              int start,
                                              int end,
                                              OrderByComparator<User> orderByComparator)
See Also:
BasePersistence.findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)

update

public static User update(User user)
See Also:
BasePersistence.update(com.liferay.portal.model.BaseModel)

update

public static User update(User user,
                          ServiceContext serviceContext)
See Also:
BasePersistence.update(com.liferay.portal.model.BaseModel, ServiceContext)

findByUuid

public static List<User> findByUuid(String uuid)
Returns all the users where uuid = ?.

Parameters:
uuid - the uuid
Returns:
the matching users

findByUuid

public static List<User> findByUuid(String uuid,
                                    int start,
                                    int end)
Returns a range of all the users where uuid = ?.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
uuid - the uuid
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
Returns:
the range of matching users

findByUuid

public static List<User> findByUuid(String uuid,
                                    int start,
                                    int end,
                                    OrderByComparator<User> orderByComparator)
Returns an ordered range of all the users where uuid = ?.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
uuid - the uuid
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
orderByComparator - the comparator to order the results by (optionally null)
Returns:
the ordered range of matching users

findByUuid

public static List<User> findByUuid(String uuid,
                                    int start,
                                    int end,
                                    OrderByComparator<User> orderByComparator,
                                    boolean retrieveFromCache)
Returns an ordered range of all the users where uuid = ?.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
uuid - the uuid
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
orderByComparator - the comparator to order the results by (optionally null)
retrieveFromCache - whether to retrieve from the finder cache
Returns:
the ordered range of matching users

findByUuid_First

public static User findByUuid_First(String uuid,
                                    OrderByComparator<User> orderByComparator)
                             throws NoSuchUserException
Returns the first user in the ordered set where uuid = ?.

Parameters:
uuid - the uuid
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the first matching user
Throws:
NoSuchUserException - if a matching user could not be found

fetchByUuid_First

public static User fetchByUuid_First(String uuid,
                                     OrderByComparator<User> orderByComparator)
Returns the first user in the ordered set where uuid = ?.

Parameters:
uuid - the uuid
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the first matching user, or null if a matching user could not be found

findByUuid_Last

public static User findByUuid_Last(String uuid,
                                   OrderByComparator<User> orderByComparator)
                            throws NoSuchUserException
Returns the last user in the ordered set where uuid = ?.

Parameters:
uuid - the uuid
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the last matching user
Throws:
NoSuchUserException - if a matching user could not be found

fetchByUuid_Last

public static User fetchByUuid_Last(String uuid,
                                    OrderByComparator<User> orderByComparator)
Returns the last user in the ordered set where uuid = ?.

Parameters:
uuid - the uuid
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the last matching user, or null if a matching user could not be found

findByUuid_PrevAndNext

public static User[] findByUuid_PrevAndNext(long userId,
                                            String uuid,
                                            OrderByComparator<User> orderByComparator)
                                     throws NoSuchUserException
Returns the users before and after the current user in the ordered set where uuid = ?.

Parameters:
userId - the primary key of the current user
uuid - the uuid
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the previous, current, and next user
Throws:
NoSuchUserException - if a user with the primary key could not be found

removeByUuid

public static void removeByUuid(String uuid)
Removes all the users where uuid = ? from the database.

Parameters:
uuid - the uuid

countByUuid

public static int countByUuid(String uuid)
Returns the number of users where uuid = ?.

Parameters:
uuid - the uuid
Returns:
the number of matching users

findByUuid_C

public static List<User> findByUuid_C(String uuid,
                                      long companyId)
Returns all the users where uuid = ? and companyId = ?.

Parameters:
uuid - the uuid
companyId - the company ID
Returns:
the matching users

findByUuid_C

public static List<User> findByUuid_C(String uuid,
                                      long companyId,
                                      int start,
                                      int end)
Returns a range of all the users where uuid = ? and companyId = ?.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
uuid - the uuid
companyId - the company ID
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
Returns:
the range of matching users

findByUuid_C

public static List<User> findByUuid_C(String uuid,
                                      long companyId,
                                      int start,
                                      int end,
                                      OrderByComparator<User> orderByComparator)
Returns an ordered range of all the users where uuid = ? and companyId = ?.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
uuid - the uuid
companyId - the company ID
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
orderByComparator - the comparator to order the results by (optionally null)
Returns:
the ordered range of matching users

findByUuid_C

public static List<User> findByUuid_C(String uuid,
                                      long companyId,
                                      int start,
                                      int end,
                                      OrderByComparator<User> orderByComparator,
                                      boolean retrieveFromCache)
Returns an ordered range of all the users where uuid = ? and companyId = ?.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
uuid - the uuid
companyId - the company ID
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
orderByComparator - the comparator to order the results by (optionally null)
retrieveFromCache - whether to retrieve from the finder cache
Returns:
the ordered range of matching users

findByUuid_C_First

public static User findByUuid_C_First(String uuid,
                                      long companyId,
                                      OrderByComparator<User> orderByComparator)
                               throws NoSuchUserException
Returns the first user in the ordered set where uuid = ? and companyId = ?.

Parameters:
uuid - the uuid
companyId - the company ID
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the first matching user
Throws:
NoSuchUserException - if a matching user could not be found

fetchByUuid_C_First

public static User fetchByUuid_C_First(String uuid,
                                       long companyId,
                                       OrderByComparator<User> orderByComparator)
Returns the first user in the ordered set where uuid = ? and companyId = ?.

Parameters:
uuid - the uuid
companyId - the company ID
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the first matching user, or null if a matching user could not be found

findByUuid_C_Last

public static User findByUuid_C_Last(String uuid,
                                     long companyId,
                                     OrderByComparator<User> orderByComparator)
                              throws NoSuchUserException
Returns the last user in the ordered set where uuid = ? and companyId = ?.

Parameters:
uuid - the uuid
companyId - the company ID
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the last matching user
Throws:
NoSuchUserException - if a matching user could not be found

fetchByUuid_C_Last

public static User fetchByUuid_C_Last(String uuid,
                                      long companyId,
                                      OrderByComparator<User> orderByComparator)
Returns the last user in the ordered set where uuid = ? and companyId = ?.

Parameters:
uuid - the uuid
companyId - the company ID
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the last matching user, or null if a matching user could not be found

findByUuid_C_PrevAndNext

public static User[] findByUuid_C_PrevAndNext(long userId,
                                              String uuid,
                                              long companyId,
                                              OrderByComparator<User> orderByComparator)
                                       throws NoSuchUserException
Returns the users before and after the current user in the ordered set where uuid = ? and companyId = ?.

Parameters:
userId - the primary key of the current user
uuid - the uuid
companyId - the company ID
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the previous, current, and next user
Throws:
NoSuchUserException - if a user with the primary key could not be found

removeByUuid_C

public static void removeByUuid_C(String uuid,
                                  long companyId)
Removes all the users where uuid = ? and companyId = ? from the database.

Parameters:
uuid - the uuid
companyId - the company ID

countByUuid_C

public static int countByUuid_C(String uuid,
                                long companyId)
Returns the number of users where uuid = ? and companyId = ?.

Parameters:
uuid - the uuid
companyId - the company ID
Returns:
the number of matching users

findByCompanyId

public static List<User> findByCompanyId(long companyId)
Returns all the users where companyId = ?.

Parameters:
companyId - the company ID
Returns:
the matching users

findByCompanyId

public static List<User> findByCompanyId(long companyId,
                                         int start,
                                         int end)
Returns a range of all the users where companyId = ?.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
companyId - the company ID
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
Returns:
the range of matching users

findByCompanyId

public static List<User> findByCompanyId(long companyId,
                                         int start,
                                         int end,
                                         OrderByComparator<User> orderByComparator)
Returns an ordered range of all the users where companyId = ?.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
companyId - the company ID
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
orderByComparator - the comparator to order the results by (optionally null)
Returns:
the ordered range of matching users

findByCompanyId

public static List<User> findByCompanyId(long companyId,
                                         int start,
                                         int end,
                                         OrderByComparator<User> orderByComparator,
                                         boolean retrieveFromCache)
Returns an ordered range of all the users where companyId = ?.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
companyId - the company ID
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
orderByComparator - the comparator to order the results by (optionally null)
retrieveFromCache - whether to retrieve from the finder cache
Returns:
the ordered range of matching users

findByCompanyId_First

public static User findByCompanyId_First(long companyId,
                                         OrderByComparator<User> orderByComparator)
                                  throws NoSuchUserException
Returns the first user in the ordered set where companyId = ?.

Parameters:
companyId - the company ID
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the first matching user
Throws:
NoSuchUserException - if a matching user could not be found

fetchByCompanyId_First

public static User fetchByCompanyId_First(long companyId,
                                          OrderByComparator<User> orderByComparator)
Returns the first user in the ordered set where companyId = ?.

Parameters:
companyId - the company ID
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the first matching user, or null if a matching user could not be found

findByCompanyId_Last

public static User findByCompanyId_Last(long companyId,
                                        OrderByComparator<User> orderByComparator)
                                 throws NoSuchUserException
Returns the last user in the ordered set where companyId = ?.

Parameters:
companyId - the company ID
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the last matching user
Throws:
NoSuchUserException - if a matching user could not be found

fetchByCompanyId_Last

public static User fetchByCompanyId_Last(long companyId,
                                         OrderByComparator<User> orderByComparator)
Returns the last user in the ordered set where companyId = ?.

Parameters:
companyId - the company ID
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the last matching user, or null if a matching user could not be found

findByCompanyId_PrevAndNext

public static User[] findByCompanyId_PrevAndNext(long userId,
                                                 long companyId,
                                                 OrderByComparator<User> orderByComparator)
                                          throws NoSuchUserException
Returns the users before and after the current user in the ordered set where companyId = ?.

Parameters:
userId - the primary key of the current user
companyId - the company ID
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the previous, current, and next user
Throws:
NoSuchUserException - if a user with the primary key could not be found

removeByCompanyId

public static void removeByCompanyId(long companyId)
Removes all the users where companyId = ? from the database.

Parameters:
companyId - the company ID

countByCompanyId

public static int countByCompanyId(long companyId)
Returns the number of users where companyId = ?.

Parameters:
companyId - the company ID
Returns:
the number of matching users

findByContactId

public static User findByContactId(long contactId)
                            throws NoSuchUserException
Returns the user where contactId = ? or throws a NoSuchUserException if it could not be found.

Parameters:
contactId - the contact ID
Returns:
the matching user
Throws:
NoSuchUserException - if a matching user could not be found

fetchByContactId

public static User fetchByContactId(long contactId)
Returns the user where contactId = ? or returns null if it could not be found. Uses the finder cache.

Parameters:
contactId - the contact ID
Returns:
the matching user, or null if a matching user could not be found

fetchByContactId

public static User fetchByContactId(long contactId,
                                    boolean retrieveFromCache)
Returns the user where contactId = ? or returns null if it could not be found, optionally using the finder cache.

Parameters:
contactId - the contact ID
retrieveFromCache - whether to retrieve from the finder cache
Returns:
the matching user, or null if a matching user could not be found

removeByContactId

public static User removeByContactId(long contactId)
                              throws NoSuchUserException
Removes the user where contactId = ? from the database.

Parameters:
contactId - the contact ID
Returns:
the user that was removed
Throws:
NoSuchUserException

countByContactId

public static int countByContactId(long contactId)
Returns the number of users where contactId = ?.

Parameters:
contactId - the contact ID
Returns:
the number of matching users

findByEmailAddress

public static List<User> findByEmailAddress(String emailAddress)
Returns all the users where emailAddress = ?.

Parameters:
emailAddress - the email address
Returns:
the matching users

findByEmailAddress

public static List<User> findByEmailAddress(String emailAddress,
                                            int start,
                                            int end)
Returns a range of all the users where emailAddress = ?.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
emailAddress - the email address
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
Returns:
the range of matching users

findByEmailAddress

public static List<User> findByEmailAddress(String emailAddress,
                                            int start,
                                            int end,
                                            OrderByComparator<User> orderByComparator)
Returns an ordered range of all the users where emailAddress = ?.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
emailAddress - the email address
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
orderByComparator - the comparator to order the results by (optionally null)
Returns:
the ordered range of matching users

findByEmailAddress

public static List<User> findByEmailAddress(String emailAddress,
                                            int start,
                                            int end,
                                            OrderByComparator<User> orderByComparator,
                                            boolean retrieveFromCache)
Returns an ordered range of all the users where emailAddress = ?.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
emailAddress - the email address
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
orderByComparator - the comparator to order the results by (optionally null)
retrieveFromCache - whether to retrieve from the finder cache
Returns:
the ordered range of matching users

findByEmailAddress_First

public static User findByEmailAddress_First(String emailAddress,
                                            OrderByComparator<User> orderByComparator)
                                     throws NoSuchUserException
Returns the first user in the ordered set where emailAddress = ?.

Parameters:
emailAddress - the email address
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the first matching user
Throws:
NoSuchUserException - if a matching user could not be found

fetchByEmailAddress_First

public static User fetchByEmailAddress_First(String emailAddress,
                                             OrderByComparator<User> orderByComparator)
Returns the first user in the ordered set where emailAddress = ?.

Parameters:
emailAddress - the email address
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the first matching user, or null if a matching user could not be found

findByEmailAddress_Last

public static User findByEmailAddress_Last(String emailAddress,
                                           OrderByComparator<User> orderByComparator)
                                    throws NoSuchUserException
Returns the last user in the ordered set where emailAddress = ?.

Parameters:
emailAddress - the email address
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the last matching user
Throws:
NoSuchUserException - if a matching user could not be found

fetchByEmailAddress_Last

public static User fetchByEmailAddress_Last(String emailAddress,
                                            OrderByComparator<User> orderByComparator)
Returns the last user in the ordered set where emailAddress = ?.

Parameters:
emailAddress - the email address
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the last matching user, or null if a matching user could not be found

findByEmailAddress_PrevAndNext

public static User[] findByEmailAddress_PrevAndNext(long userId,
                                                    String emailAddress,
                                                    OrderByComparator<User> orderByComparator)
                                             throws NoSuchUserException
Returns the users before and after the current user in the ordered set where emailAddress = ?.

Parameters:
userId - the primary key of the current user
emailAddress - the email address
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the previous, current, and next user
Throws:
NoSuchUserException - if a user with the primary key could not be found

removeByEmailAddress

public static void removeByEmailAddress(String emailAddress)
Removes all the users where emailAddress = ? from the database.

Parameters:
emailAddress - the email address

countByEmailAddress

public static int countByEmailAddress(String emailAddress)
Returns the number of users where emailAddress = ?.

Parameters:
emailAddress - the email address
Returns:
the number of matching users

findByPortraitId

public static User findByPortraitId(long portraitId)
                             throws NoSuchUserException
Returns the user where portraitId = ? or throws a NoSuchUserException if it could not be found.

Parameters:
portraitId - the portrait ID
Returns:
the matching user
Throws:
NoSuchUserException - if a matching user could not be found

fetchByPortraitId

public static User fetchByPortraitId(long portraitId)
Returns the user where portraitId = ? or returns null if it could not be found. Uses the finder cache.

Parameters:
portraitId - the portrait ID
Returns:
the matching user, or null if a matching user could not be found

fetchByPortraitId

public static User fetchByPortraitId(long portraitId,
                                     boolean retrieveFromCache)
Returns the user where portraitId = ? or returns null if it could not be found, optionally using the finder cache.

Parameters:
portraitId - the portrait ID
retrieveFromCache - whether to retrieve from the finder cache
Returns:
the matching user, or null if a matching user could not be found

removeByPortraitId

public static User removeByPortraitId(long portraitId)
                               throws NoSuchUserException
Removes the user where portraitId = ? from the database.

Parameters:
portraitId - the portrait ID
Returns:
the user that was removed
Throws:
NoSuchUserException

countByPortraitId

public static int countByPortraitId(long portraitId)
Returns the number of users where portraitId = ?.

Parameters:
portraitId - the portrait ID
Returns:
the number of matching users

findByC_U

public static User findByC_U(long companyId,
                             long userId)
                      throws NoSuchUserException
Returns the user where companyId = ? and userId = ? or throws a NoSuchUserException if it could not be found.

Parameters:
companyId - the company ID
userId - the user ID
Returns:
the matching user
Throws:
NoSuchUserException - if a matching user could not be found

fetchByC_U

public static User fetchByC_U(long companyId,
                              long userId)
Returns the user where companyId = ? and userId = ? or returns null if it could not be found. Uses the finder cache.

Parameters:
companyId - the company ID
userId - the user ID
Returns:
the matching user, or null if a matching user could not be found

fetchByC_U

public static User fetchByC_U(long companyId,
                              long userId,
                              boolean retrieveFromCache)
Returns the user where companyId = ? and userId = ? or returns null if it could not be found, optionally using the finder cache.

Parameters:
companyId - the company ID
userId - the user ID
retrieveFromCache - whether to retrieve from the finder cache
Returns:
the matching user, or null if a matching user could not be found

removeByC_U

public static User removeByC_U(long companyId,
                               long userId)
                        throws NoSuchUserException
Removes the user where companyId = ? and userId = ? from the database.

Parameters:
companyId - the company ID
userId - the user ID
Returns:
the user that was removed
Throws:
NoSuchUserException

countByC_U

public static int countByC_U(long companyId,
                             long userId)
Returns the number of users where companyId = ? and userId = ?.

Parameters:
companyId - the company ID
userId - the user ID
Returns:
the number of matching users

findByC_CD

public static List<User> findByC_CD(long companyId,
                                    Date createDate)
Returns all the users where companyId = ? and createDate = ?.

Parameters:
companyId - the company ID
createDate - the create date
Returns:
the matching users

findByC_CD

public static List<User> findByC_CD(long companyId,
                                    Date createDate,
                                    int start,
                                    int end)
Returns a range of all the users where companyId = ? and createDate = ?.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
companyId - the company ID
createDate - the create date
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
Returns:
the range of matching users

findByC_CD

public static List<User> findByC_CD(long companyId,
                                    Date createDate,
                                    int start,
                                    int end,
                                    OrderByComparator<User> orderByComparator)
Returns an ordered range of all the users where companyId = ? and createDate = ?.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
companyId - the company ID
createDate - the create date
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
orderByComparator - the comparator to order the results by (optionally null)
Returns:
the ordered range of matching users

findByC_CD

public static List<User> findByC_CD(long companyId,
                                    Date createDate,
                                    int start,
                                    int end,
                                    OrderByComparator<User> orderByComparator,
                                    boolean retrieveFromCache)
Returns an ordered range of all the users where companyId = ? and createDate = ?.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
companyId - the company ID
createDate - the create date
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
orderByComparator - the comparator to order the results by (optionally null)
retrieveFromCache - whether to retrieve from the finder cache
Returns:
the ordered range of matching users

findByC_CD_First

public static User findByC_CD_First(long companyId,
                                    Date createDate,
                                    OrderByComparator<User> orderByComparator)
                             throws NoSuchUserException
Returns the first user in the ordered set where companyId = ? and createDate = ?.

Parameters:
companyId - the company ID
createDate - the create date
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the first matching user
Throws:
NoSuchUserException - if a matching user could not be found

fetchByC_CD_First

public static User fetchByC_CD_First(long companyId,
                                     Date createDate,
                                     OrderByComparator<User> orderByComparator)
Returns the first user in the ordered set where companyId = ? and createDate = ?.

Parameters:
companyId - the company ID
createDate - the create date
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the first matching user, or null if a matching user could not be found

findByC_CD_Last

public static User findByC_CD_Last(long companyId,
                                   Date createDate,
                                   OrderByComparator<User> orderByComparator)
                            throws NoSuchUserException
Returns the last user in the ordered set where companyId = ? and createDate = ?.

Parameters:
companyId - the company ID
createDate - the create date
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the last matching user
Throws:
NoSuchUserException - if a matching user could not be found

fetchByC_CD_Last

public static User fetchByC_CD_Last(long companyId,
                                    Date createDate,
                                    OrderByComparator<User> orderByComparator)
Returns the last user in the ordered set where companyId = ? and createDate = ?.

Parameters:
companyId - the company ID
createDate - the create date
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the last matching user, or null if a matching user could not be found

findByC_CD_PrevAndNext

public static User[] findByC_CD_PrevAndNext(long userId,
                                            long companyId,
                                            Date createDate,
                                            OrderByComparator<User> orderByComparator)
                                     throws NoSuchUserException
Returns the users before and after the current user in the ordered set where companyId = ? and createDate = ?.

Parameters:
userId - the primary key of the current user
companyId - the company ID
createDate - the create date
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the previous, current, and next user
Throws:
NoSuchUserException - if a user with the primary key could not be found

removeByC_CD

public static void removeByC_CD(long companyId,
                                Date createDate)
Removes all the users where companyId = ? and createDate = ? from the database.

Parameters:
companyId - the company ID
createDate - the create date

countByC_CD

public static int countByC_CD(long companyId,
                              Date createDate)
Returns the number of users where companyId = ? and createDate = ?.

Parameters:
companyId - the company ID
createDate - the create date
Returns:
the number of matching users

findByC_MD

public static List<User> findByC_MD(long companyId,
                                    Date modifiedDate)
Returns all the users where companyId = ? and modifiedDate = ?.

Parameters:
companyId - the company ID
modifiedDate - the modified date
Returns:
the matching users

findByC_MD

public static List<User> findByC_MD(long companyId,
                                    Date modifiedDate,
                                    int start,
                                    int end)
Returns a range of all the users where companyId = ? and modifiedDate = ?.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
companyId - the company ID
modifiedDate - the modified date
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
Returns:
the range of matching users

findByC_MD

public static List<User> findByC_MD(long companyId,
                                    Date modifiedDate,
                                    int start,
                                    int end,
                                    OrderByComparator<User> orderByComparator)
Returns an ordered range of all the users where companyId = ? and modifiedDate = ?.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
companyId - the company ID
modifiedDate - the modified date
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
orderByComparator - the comparator to order the results by (optionally null)
Returns:
the ordered range of matching users

findByC_MD

public static List<User> findByC_MD(long companyId,
                                    Date modifiedDate,
                                    int start,
                                    int end,
                                    OrderByComparator<User> orderByComparator,
                                    boolean retrieveFromCache)
Returns an ordered range of all the users where companyId = ? and modifiedDate = ?.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
companyId - the company ID
modifiedDate - the modified date
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
orderByComparator - the comparator to order the results by (optionally null)
retrieveFromCache - whether to retrieve from the finder cache
Returns:
the ordered range of matching users

findByC_MD_First

public static User findByC_MD_First(long companyId,
                                    Date modifiedDate,
                                    OrderByComparator<User> orderByComparator)
                             throws NoSuchUserException
Returns the first user in the ordered set where companyId = ? and modifiedDate = ?.

Parameters:
companyId - the company ID
modifiedDate - the modified date
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the first matching user
Throws:
NoSuchUserException - if a matching user could not be found

fetchByC_MD_First

public static User fetchByC_MD_First(long companyId,
                                     Date modifiedDate,
                                     OrderByComparator<User> orderByComparator)
Returns the first user in the ordered set where companyId = ? and modifiedDate = ?.

Parameters:
companyId - the company ID
modifiedDate - the modified date
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the first matching user, or null if a matching user could not be found

findByC_MD_Last

public static User findByC_MD_Last(long companyId,
                                   Date modifiedDate,
                                   OrderByComparator<User> orderByComparator)
                            throws NoSuchUserException
Returns the last user in the ordered set where companyId = ? and modifiedDate = ?.

Parameters:
companyId - the company ID
modifiedDate - the modified date
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the last matching user
Throws:
NoSuchUserException - if a matching user could not be found

fetchByC_MD_Last

public static User fetchByC_MD_Last(long companyId,
                                    Date modifiedDate,
                                    OrderByComparator<User> orderByComparator)
Returns the last user in the ordered set where companyId = ? and modifiedDate = ?.

Parameters:
companyId - the company ID
modifiedDate - the modified date
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the last matching user, or null if a matching user could not be found

findByC_MD_PrevAndNext

public static User[] findByC_MD_PrevAndNext(long userId,
                                            long companyId,
                                            Date modifiedDate,
                                            OrderByComparator<User> orderByComparator)
                                     throws NoSuchUserException
Returns the users before and after the current user in the ordered set where companyId = ? and modifiedDate = ?.

Parameters:
userId - the primary key of the current user
companyId - the company ID
modifiedDate - the modified date
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the previous, current, and next user
Throws:
NoSuchUserException - if a user with the primary key could not be found

removeByC_MD

public static void removeByC_MD(long companyId,
                                Date modifiedDate)
Removes all the users where companyId = ? and modifiedDate = ? from the database.

Parameters:
companyId - the company ID
modifiedDate - the modified date

countByC_MD

public static int countByC_MD(long companyId,
                              Date modifiedDate)
Returns the number of users where companyId = ? and modifiedDate = ?.

Parameters:
companyId - the company ID
modifiedDate - the modified date
Returns:
the number of matching users

findByC_DU

public static User findByC_DU(long companyId,
                              boolean defaultUser)
                       throws NoSuchUserException
Returns the user where companyId = ? and defaultUser = ? or throws a NoSuchUserException if it could not be found.

Parameters:
companyId - the company ID
defaultUser - the default user
Returns:
the matching user
Throws:
NoSuchUserException - if a matching user could not be found

fetchByC_DU

public static User fetchByC_DU(long companyId,
                               boolean defaultUser)
Returns the user where companyId = ? and defaultUser = ? or returns null if it could not be found. Uses the finder cache.

Parameters:
companyId - the company ID
defaultUser - the default user
Returns:
the matching user, or null if a matching user could not be found

fetchByC_DU

public static User fetchByC_DU(long companyId,
                               boolean defaultUser,
                               boolean retrieveFromCache)
Returns the user where companyId = ? and defaultUser = ? or returns null if it could not be found, optionally using the finder cache.

Parameters:
companyId - the company ID
defaultUser - the default user
retrieveFromCache - whether to retrieve from the finder cache
Returns:
the matching user, or null if a matching user could not be found

removeByC_DU

public static User removeByC_DU(long companyId,
                                boolean defaultUser)
                         throws NoSuchUserException
Removes the user where companyId = ? and defaultUser = ? from the database.

Parameters:
companyId - the company ID
defaultUser - the default user
Returns:
the user that was removed
Throws:
NoSuchUserException

countByC_DU

public static int countByC_DU(long companyId,
                              boolean defaultUser)
Returns the number of users where companyId = ? and defaultUser = ?.

Parameters:
companyId - the company ID
defaultUser - the default user
Returns:
the number of matching users

findByC_SN

public static User findByC_SN(long companyId,
                              String screenName)
                       throws NoSuchUserException
Returns the user where companyId = ? and screenName = ? or throws a NoSuchUserException if it could not be found.

Parameters:
companyId - the company ID
screenName - the screen name
Returns:
the matching user
Throws:
NoSuchUserException - if a matching user could not be found

fetchByC_SN

public static User fetchByC_SN(long companyId,
                               String screenName)
Returns the user where companyId = ? and screenName = ? or returns null if it could not be found. Uses the finder cache.

Parameters:
companyId - the company ID
screenName - the screen name
Returns:
the matching user, or null if a matching user could not be found

fetchByC_SN

public static User fetchByC_SN(long companyId,
                               String screenName,
                               boolean retrieveFromCache)
Returns the user where companyId = ? and screenName = ? or returns null if it could not be found, optionally using the finder cache.

Parameters:
companyId - the company ID
screenName - the screen name
retrieveFromCache - whether to retrieve from the finder cache
Returns:
the matching user, or null if a matching user could not be found

removeByC_SN

public static User removeByC_SN(long companyId,
                                String screenName)
                         throws NoSuchUserException
Removes the user where companyId = ? and screenName = ? from the database.

Parameters:
companyId - the company ID
screenName - the screen name
Returns:
the user that was removed
Throws:
NoSuchUserException

countByC_SN

public static int countByC_SN(long companyId,
                              String screenName)
Returns the number of users where companyId = ? and screenName = ?.

Parameters:
companyId - the company ID
screenName - the screen name
Returns:
the number of matching users

findByC_EA

public static User findByC_EA(long companyId,
                              String emailAddress)
                       throws NoSuchUserException
Returns the user where companyId = ? and emailAddress = ? or throws a NoSuchUserException if it could not be found.

Parameters:
companyId - the company ID
emailAddress - the email address
Returns:
the matching user
Throws:
NoSuchUserException - if a matching user could not be found

fetchByC_EA

public static User fetchByC_EA(long companyId,
                               String emailAddress)
Returns the user where companyId = ? and emailAddress = ? or returns null if it could not be found. Uses the finder cache.

Parameters:
companyId - the company ID
emailAddress - the email address
Returns:
the matching user, or null if a matching user could not be found

fetchByC_EA

public static User fetchByC_EA(long companyId,
                               String emailAddress,
                               boolean retrieveFromCache)
Returns the user where companyId = ? and emailAddress = ? or returns null if it could not be found, optionally using the finder cache.

Parameters:
companyId - the company ID
emailAddress - the email address
retrieveFromCache - whether to retrieve from the finder cache
Returns:
the matching user, or null if a matching user could not be found

removeByC_EA

public static User removeByC_EA(long companyId,
                                String emailAddress)
                         throws NoSuchUserException
Removes the user where companyId = ? and emailAddress = ? from the database.

Parameters:
companyId - the company ID
emailAddress - the email address
Returns:
the user that was removed
Throws:
NoSuchUserException

countByC_EA

public static int countByC_EA(long companyId,
                              String emailAddress)
Returns the number of users where companyId = ? and emailAddress = ?.

Parameters:
companyId - the company ID
emailAddress - the email address
Returns:
the number of matching users

findByC_FID

public static User findByC_FID(long companyId,
                               long facebookId)
                        throws NoSuchUserException
Returns the user where companyId = ? and facebookId = ? or throws a NoSuchUserException if it could not be found.

Parameters:
companyId - the company ID
facebookId - the facebook ID
Returns:
the matching user
Throws:
NoSuchUserException - if a matching user could not be found

fetchByC_FID

public static User fetchByC_FID(long companyId,
                                long facebookId)
Returns the user where companyId = ? and facebookId = ? or returns null if it could not be found. Uses the finder cache.

Parameters:
companyId - the company ID
facebookId - the facebook ID
Returns:
the matching user, or null if a matching user could not be found

fetchByC_FID

public static User fetchByC_FID(long companyId,
                                long facebookId,
                                boolean retrieveFromCache)
Returns the user where companyId = ? and facebookId = ? or returns null if it could not be found, optionally using the finder cache.

Parameters:
companyId - the company ID
facebookId - the facebook ID
retrieveFromCache - whether to retrieve from the finder cache
Returns:
the matching user, or null if a matching user could not be found

removeByC_FID

public static User removeByC_FID(long companyId,
                                 long facebookId)
                          throws NoSuchUserException
Removes the user where companyId = ? and facebookId = ? from the database.

Parameters:
companyId - the company ID
facebookId - the facebook ID
Returns:
the user that was removed
Throws:
NoSuchUserException

countByC_FID

public static int countByC_FID(long companyId,
                               long facebookId)
Returns the number of users where companyId = ? and facebookId = ?.

Parameters:
companyId - the company ID
facebookId - the facebook ID
Returns:
the number of matching users

findByC_O

public static User findByC_O(long companyId,
                             String openId)
                      throws NoSuchUserException
Returns the user where companyId = ? and openId = ? or throws a NoSuchUserException if it could not be found.

Parameters:
companyId - the company ID
openId - the open ID
Returns:
the matching user
Throws:
NoSuchUserException - if a matching user could not be found

fetchByC_O

public static User fetchByC_O(long companyId,
                              String openId)
Returns the user where companyId = ? and openId = ? or returns null if it could not be found. Uses the finder cache.

Parameters:
companyId - the company ID
openId - the open ID
Returns:
the matching user, or null if a matching user could not be found

fetchByC_O

public static User fetchByC_O(long companyId,
                              String openId,
                              boolean retrieveFromCache)
Returns the user where companyId = ? and openId = ? or returns null if it could not be found, optionally using the finder cache.

Parameters:
companyId - the company ID
openId - the open ID
retrieveFromCache - whether to retrieve from the finder cache
Returns:
the matching user, or null if a matching user could not be found

removeByC_O

public static User removeByC_O(long companyId,
                               String openId)
                        throws NoSuchUserException
Removes the user where companyId = ? and openId = ? from the database.

Parameters:
companyId - the company ID
openId - the open ID
Returns:
the user that was removed
Throws:
NoSuchUserException

countByC_O

public static int countByC_O(long companyId,
                             String openId)
Returns the number of users where companyId = ? and openId = ?.

Parameters:
companyId - the company ID
openId - the open ID
Returns:
the number of matching users

findByC_S

public static List<User> findByC_S(long companyId,
                                   int status)
Returns all the users where companyId = ? and status = ?.

Parameters:
companyId - the company ID
status - the status
Returns:
the matching users

findByC_S

public static List<User> findByC_S(long companyId,
                                   int status,
                                   int start,
                                   int end)
Returns a range of all the users where companyId = ? and status = ?.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
companyId - the company ID
status - the status
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
Returns:
the range of matching users

findByC_S

public static List<User> findByC_S(long companyId,
                                   int status,
                                   int start,
                                   int end,
                                   OrderByComparator<User> orderByComparator)
Returns an ordered range of all the users where companyId = ? and status = ?.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
companyId - the company ID
status - the status
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
orderByComparator - the comparator to order the results by (optionally null)
Returns:
the ordered range of matching users

findByC_S

public static List<User> findByC_S(long companyId,
                                   int status,
                                   int start,
                                   int end,
                                   OrderByComparator<User> orderByComparator,
                                   boolean retrieveFromCache)
Returns an ordered range of all the users where companyId = ? and status = ?.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
companyId - the company ID
status - the status
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
orderByComparator - the comparator to order the results by (optionally null)
retrieveFromCache - whether to retrieve from the finder cache
Returns:
the ordered range of matching users

findByC_S_First

public static User findByC_S_First(long companyId,
                                   int status,
                                   OrderByComparator<User> orderByComparator)
                            throws NoSuchUserException
Returns the first user in the ordered set where companyId = ? and status = ?.

Parameters:
companyId - the company ID
status - the status
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the first matching user
Throws:
NoSuchUserException - if a matching user could not be found

fetchByC_S_First

public static User fetchByC_S_First(long companyId,
                                    int status,
                                    OrderByComparator<User> orderByComparator)
Returns the first user in the ordered set where companyId = ? and status = ?.

Parameters:
companyId - the company ID
status - the status
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the first matching user, or null if a matching user could not be found

findByC_S_Last

public static User findByC_S_Last(long companyId,
                                  int status,
                                  OrderByComparator<User> orderByComparator)
                           throws NoSuchUserException
Returns the last user in the ordered set where companyId = ? and status = ?.

Parameters:
companyId - the company ID
status - the status
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the last matching user
Throws:
NoSuchUserException - if a matching user could not be found

fetchByC_S_Last

public static User fetchByC_S_Last(long companyId,
                                   int status,
                                   OrderByComparator<User> orderByComparator)
Returns the last user in the ordered set where companyId = ? and status = ?.

Parameters:
companyId - the company ID
status - the status
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the last matching user, or null if a matching user could not be found

findByC_S_PrevAndNext

public static User[] findByC_S_PrevAndNext(long userId,
                                           long companyId,
                                           int status,
                                           OrderByComparator<User> orderByComparator)
                                    throws NoSuchUserException
Returns the users before and after the current user in the ordered set where companyId = ? and status = ?.

Parameters:
userId - the primary key of the current user
companyId - the company ID
status - the status
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the previous, current, and next user
Throws:
NoSuchUserException - if a user with the primary key could not be found

removeByC_S

public static void removeByC_S(long companyId,
                               int status)
Removes all the users where companyId = ? and status = ? from the database.

Parameters:
companyId - the company ID
status - the status

countByC_S

public static int countByC_S(long companyId,
                             int status)
Returns the number of users where companyId = ? and status = ?.

Parameters:
companyId - the company ID
status - the status
Returns:
the number of matching users

findByC_CD_MD

public static List<User> findByC_CD_MD(long companyId,
                                       Date createDate,
                                       Date modifiedDate)
Returns all the users where companyId = ? and createDate = ? and modifiedDate = ?.

Parameters:
companyId - the company ID
createDate - the create date
modifiedDate - the modified date
Returns:
the matching users

findByC_CD_MD

public static List<User> findByC_CD_MD(long companyId,
                                       Date createDate,
                                       Date modifiedDate,
                                       int start,
                                       int end)
Returns a range of all the users where companyId = ? and createDate = ? and modifiedDate = ?.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
companyId - the company ID
createDate - the create date
modifiedDate - the modified date
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
Returns:
the range of matching users

findByC_CD_MD

public static List<User> findByC_CD_MD(long companyId,
                                       Date createDate,
                                       Date modifiedDate,
                                       int start,
                                       int end,
                                       OrderByComparator<User> orderByComparator)
Returns an ordered range of all the users where companyId = ? and createDate = ? and modifiedDate = ?.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
companyId - the company ID
createDate - the create date
modifiedDate - the modified date
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
orderByComparator - the comparator to order the results by (optionally null)
Returns:
the ordered range of matching users

findByC_CD_MD

public static List<User> findByC_CD_MD(long companyId,
                                       Date createDate,
                                       Date modifiedDate,
                                       int start,
                                       int end,
                                       OrderByComparator<User> orderByComparator,
                                       boolean retrieveFromCache)
Returns an ordered range of all the users where companyId = ? and createDate = ? and modifiedDate = ?.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
companyId - the company ID
createDate - the create date
modifiedDate - the modified date
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
orderByComparator - the comparator to order the results by (optionally null)
retrieveFromCache - whether to retrieve from the finder cache
Returns:
the ordered range of matching users

findByC_CD_MD_First

public static User findByC_CD_MD_First(long companyId,
                                       Date createDate,
                                       Date modifiedDate,
                                       OrderByComparator<User> orderByComparator)
                                throws NoSuchUserException
Returns the first user in the ordered set where companyId = ? and createDate = ? and modifiedDate = ?.

Parameters:
companyId - the company ID
createDate - the create date
modifiedDate - the modified date
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the first matching user
Throws:
NoSuchUserException - if a matching user could not be found

fetchByC_CD_MD_First

public static User fetchByC_CD_MD_First(long companyId,
                                        Date createDate,
                                        Date modifiedDate,
                                        OrderByComparator<User> orderByComparator)
Returns the first user in the ordered set where companyId = ? and createDate = ? and modifiedDate = ?.

Parameters:
companyId - the company ID
createDate - the create date
modifiedDate - the modified date
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the first matching user, or null if a matching user could not be found

findByC_CD_MD_Last

public static User findByC_CD_MD_Last(long companyId,
                                      Date createDate,
                                      Date modifiedDate,
                                      OrderByComparator<User> orderByComparator)
                               throws NoSuchUserException
Returns the last user in the ordered set where companyId = ? and createDate = ? and modifiedDate = ?.

Parameters:
companyId - the company ID
createDate - the create date
modifiedDate - the modified date
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the last matching user
Throws:
NoSuchUserException - if a matching user could not be found

fetchByC_CD_MD_Last

public static User fetchByC_CD_MD_Last(long companyId,
                                       Date createDate,
                                       Date modifiedDate,
                                       OrderByComparator<User> orderByComparator)
Returns the last user in the ordered set where companyId = ? and createDate = ? and modifiedDate = ?.

Parameters:
companyId - the company ID
createDate - the create date
modifiedDate - the modified date
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the last matching user, or null if a matching user could not be found

findByC_CD_MD_PrevAndNext

public static User[] findByC_CD_MD_PrevAndNext(long userId,
                                               long companyId,
                                               Date createDate,
                                               Date modifiedDate,
                                               OrderByComparator<User> orderByComparator)
                                        throws NoSuchUserException
Returns the users before and after the current user in the ordered set where companyId = ? and createDate = ? and modifiedDate = ?.

Parameters:
userId - the primary key of the current user
companyId - the company ID
createDate - the create date
modifiedDate - the modified date
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the previous, current, and next user
Throws:
NoSuchUserException - if a user with the primary key could not be found

removeByC_CD_MD

public static void removeByC_CD_MD(long companyId,
                                   Date createDate,
                                   Date modifiedDate)
Removes all the users where companyId = ? and createDate = ? and modifiedDate = ? from the database.

Parameters:
companyId - the company ID
createDate - the create date
modifiedDate - the modified date

countByC_CD_MD

public static int countByC_CD_MD(long companyId,
                                 Date createDate,
                                 Date modifiedDate)
Returns the number of users where companyId = ? and createDate = ? and modifiedDate = ?.

Parameters:
companyId - the company ID
createDate - the create date
modifiedDate - the modified date
Returns:
the number of matching users

findByC_DU_S

public static List<User> findByC_DU_S(long companyId,
                                      boolean defaultUser,
                                      int status)
Returns all the users where companyId = ? and defaultUser = ? and status = ?.

Parameters:
companyId - the company ID
defaultUser - the default user
status - the status
Returns:
the matching users

findByC_DU_S

public static List<User> findByC_DU_S(long companyId,
                                      boolean defaultUser,
                                      int status,
                                      int start,
                                      int end)
Returns a range of all the users where companyId = ? and defaultUser = ? and status = ?.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
companyId - the company ID
defaultUser - the default user
status - the status
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
Returns:
the range of matching users

findByC_DU_S

public static List<User> findByC_DU_S(long companyId,
                                      boolean defaultUser,
                                      int status,
                                      int start,
                                      int end,
                                      OrderByComparator<User> orderByComparator)
Returns an ordered range of all the users where companyId = ? and defaultUser = ? and status = ?.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
companyId - the company ID
defaultUser - the default user
status - the status
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
orderByComparator - the comparator to order the results by (optionally null)
Returns:
the ordered range of matching users

findByC_DU_S

public static List<User> findByC_DU_S(long companyId,
                                      boolean defaultUser,
                                      int status,
                                      int start,
                                      int end,
                                      OrderByComparator<User> orderByComparator,
                                      boolean retrieveFromCache)
Returns an ordered range of all the users where companyId = ? and defaultUser = ? and status = ?.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
companyId - the company ID
defaultUser - the default user
status - the status
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
orderByComparator - the comparator to order the results by (optionally null)
retrieveFromCache - whether to retrieve from the finder cache
Returns:
the ordered range of matching users

findByC_DU_S_First

public static User findByC_DU_S_First(long companyId,
                                      boolean defaultUser,
                                      int status,
                                      OrderByComparator<User> orderByComparator)
                               throws NoSuchUserException
Returns the first user in the ordered set where companyId = ? and defaultUser = ? and status = ?.

Parameters:
companyId - the company ID
defaultUser - the default user
status - the status
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the first matching user
Throws:
NoSuchUserException - if a matching user could not be found

fetchByC_DU_S_First

public static User fetchByC_DU_S_First(long companyId,
                                       boolean defaultUser,
                                       int status,
                                       OrderByComparator<User> orderByComparator)
Returns the first user in the ordered set where companyId = ? and defaultUser = ? and status = ?.

Parameters:
companyId - the company ID
defaultUser - the default user
status - the status
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the first matching user, or null if a matching user could not be found

findByC_DU_S_Last

public static User findByC_DU_S_Last(long companyId,
                                     boolean defaultUser,
                                     int status,
                                     OrderByComparator<User> orderByComparator)
                              throws NoSuchUserException
Returns the last user in the ordered set where companyId = ? and defaultUser = ? and status = ?.

Parameters:
companyId - the company ID
defaultUser - the default user
status - the status
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the last matching user
Throws:
NoSuchUserException - if a matching user could not be found

fetchByC_DU_S_Last

public static User fetchByC_DU_S_Last(long companyId,
                                      boolean defaultUser,
                                      int status,
                                      OrderByComparator<User> orderByComparator)
Returns the last user in the ordered set where companyId = ? and defaultUser = ? and status = ?.

Parameters:
companyId - the company ID
defaultUser - the default user
status - the status
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the last matching user, or null if a matching user could not be found

findByC_DU_S_PrevAndNext

public static User[] findByC_DU_S_PrevAndNext(long userId,
                                              long companyId,
                                              boolean defaultUser,
                                              int status,
                                              OrderByComparator<User> orderByComparator)
                                       throws NoSuchUserException
Returns the users before and after the current user in the ordered set where companyId = ? and defaultUser = ? and status = ?.

Parameters:
userId - the primary key of the current user
companyId - the company ID
defaultUser - the default user
status - the status
orderByComparator - the comparator to order the set by (optionally null)
Returns:
the previous, current, and next user
Throws:
NoSuchUserException - if a user with the primary key could not be found

removeByC_DU_S

public static void removeByC_DU_S(long companyId,
                                  boolean defaultUser,
                                  int status)
Removes all the users where companyId = ? and defaultUser = ? and status = ? from the database.

Parameters:
companyId - the company ID
defaultUser - the default user
status - the status

countByC_DU_S

public static int countByC_DU_S(long companyId,
                                boolean defaultUser,
                                int status)
Returns the number of users where companyId = ? and defaultUser = ? and status = ?.

Parameters:
companyId - the company ID
defaultUser - the default user
status - the status
Returns:
the number of matching users

cacheResult

public static void cacheResult(User user)
Caches the user in the entity cache if it is enabled.

Parameters:
user - the user

cacheResult

public static void cacheResult(List<User> users)
Caches the users in the entity cache if it is enabled.

Parameters:
users - the users

create

public static User create(long userId)
Creates a new user with the primary key. Does not add the user to the database.

Parameters:
userId - the primary key for the new user
Returns:
the new user

remove

public static User remove(long userId)
                   throws NoSuchUserException
Removes the user with the primary key from the database. Also notifies the appropriate model listeners.

Parameters:
userId - the primary key of the user
Returns:
the user that was removed
Throws:
NoSuchUserException - if a user with the primary key could not be found

updateImpl

public static User updateImpl(User user)

findByPrimaryKey

public static User findByPrimaryKey(long userId)
                             throws NoSuchUserException
Returns the user with the primary key or throws a NoSuchUserException if it could not be found.

Parameters:
userId - the primary key of the user
Returns:
the user
Throws:
NoSuchUserException - if a user with the primary key could not be found

fetchByPrimaryKey

public static User fetchByPrimaryKey(long userId)
Returns the user with the primary key or returns null if it could not be found.

Parameters:
userId - the primary key of the user
Returns:
the user, or null if a user with the primary key could not be found

fetchByPrimaryKeys

public static Map<Serializable,User> fetchByPrimaryKeys(Set<Serializable> primaryKeys)

findAll

public static List<User> findAll()
Returns all the users.

Returns:
the users

findAll

public static List<User> findAll(int start,
                                 int end)
Returns a range of all the users.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
Returns:
the range of users

findAll

public static List<User> findAll(int start,
                                 int end,
                                 OrderByComparator<User> orderByComparator)
Returns an ordered range of all the users.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
orderByComparator - the comparator to order the results by (optionally null)
Returns:
the ordered range of users

findAll

public static List<User> findAll(int start,
                                 int end,
                                 OrderByComparator<User> orderByComparator,
                                 boolean retrieveFromCache)
Returns an ordered range of all the users.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
orderByComparator - the comparator to order the results by (optionally null)
retrieveFromCache - whether to retrieve from the finder cache
Returns:
the ordered range of users

removeAll

public static void removeAll()
Removes all the users from the database.


countAll

public static int countAll()
Returns the number of users.

Returns:
the number of users

getGroupPrimaryKeys

public static long[] getGroupPrimaryKeys(long pk)
Returns the primaryKeys of groups associated with the user.

Parameters:
pk - the primary key of the user
Returns:
long[] of the primaryKeys of groups associated with the user

getGroups

public static List<Group> getGroups(long pk)
Returns all the groups associated with the user.

Parameters:
pk - the primary key of the user
Returns:
the groups associated with the user

getGroups

public static List<Group> getGroups(long pk,
                                    int start,
                                    int end)
Returns a range of all the groups associated with the user.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
pk - the primary key of the user
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
Returns:
the range of groups associated with the user

getGroups

public static List<Group> getGroups(long pk,
                                    int start,
                                    int end,
                                    OrderByComparator<Group> orderByComparator)
Returns an ordered range of all the groups associated with the user.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
pk - the primary key of the user
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
orderByComparator - the comparator to order the results by (optionally null)
Returns:
the ordered range of groups associated with the user

getGroupsSize

public static int getGroupsSize(long pk)
Returns the number of groups associated with the user.

Parameters:
pk - the primary key of the user
Returns:
the number of groups associated with the user

containsGroup

public static boolean containsGroup(long pk,
                                    long groupPK)
Returns true if the group is associated with the user.

Parameters:
pk - the primary key of the user
groupPK - the primary key of the group
Returns:
true if the group is associated with the user; false otherwise

containsGroups

public static boolean containsGroups(long pk)
Returns true if the user has any groups associated with it.

Parameters:
pk - the primary key of the user to check for associations with groups
Returns:
true if the user has any groups associated with it; false otherwise

addGroup

public static void addGroup(long pk,
                            long groupPK)
Adds an association between the user and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
groupPK - the primary key of the group

addGroup

public static void addGroup(long pk,
                            Group group)
Adds an association between the user and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
group - the group

addGroups

public static void addGroups(long pk,
                             long[] groupPKs)
Adds an association between the user and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
groupPKs - the primary keys of the groups

addGroups

public static void addGroups(long pk,
                             List<Group> groups)
Adds an association between the user and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
groups - the groups

clearGroups

public static void clearGroups(long pk)
Clears all associations between the user and its groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user to clear the associated groups from

removeGroup

public static void removeGroup(long pk,
                               long groupPK)
Removes the association between the user and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
groupPK - the primary key of the group

removeGroup

public static void removeGroup(long pk,
                               Group group)
Removes the association between the user and the group. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
group - the group

removeGroups

public static void removeGroups(long pk,
                                long[] groupPKs)
Removes the association between the user and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
groupPKs - the primary keys of the groups

removeGroups

public static void removeGroups(long pk,
                                List<Group> groups)
Removes the association between the user and the groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
groups - the groups

setGroups

public static void setGroups(long pk,
                             long[] groupPKs)
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.

Parameters:
pk - the primary key of the user
groupPKs - the primary keys of the groups to be associated with the user

setGroups

public static void setGroups(long pk,
                             List<Group> groups)
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.

Parameters:
pk - the primary key of the user
groups - the groups to be associated with the user

getOrganizationPrimaryKeys

public static long[] getOrganizationPrimaryKeys(long pk)
Returns the primaryKeys of organizations associated with the user.

Parameters:
pk - the primary key of the user
Returns:
long[] of the primaryKeys of organizations associated with the user

getOrganizations

public static List<Organization> getOrganizations(long pk)
Returns all the organizations associated with the user.

Parameters:
pk - the primary key of the user
Returns:
the organizations associated with the user

getOrganizations

public static List<Organization> getOrganizations(long pk,
                                                  int start,
                                                  int end)
Returns a range of all the organizations associated with the user.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
pk - the primary key of the user
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
Returns:
the range of organizations associated with the user

getOrganizations

public static List<Organization> getOrganizations(long pk,
                                                  int start,
                                                  int end,
                                                  OrderByComparator<Organization> orderByComparator)
Returns an ordered range of all the organizations associated with the user.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
pk - the primary key of the user
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
orderByComparator - the comparator to order the results by (optionally null)
Returns:
the ordered range of organizations associated with the user

getOrganizationsSize

public static int getOrganizationsSize(long pk)
Returns the number of organizations associated with the user.

Parameters:
pk - the primary key of the user
Returns:
the number of organizations associated with the user

containsOrganization

public static boolean containsOrganization(long pk,
                                           long organizationPK)
Returns true if the organization is associated with the user.

Parameters:
pk - the primary key of the user
organizationPK - the primary key of the organization
Returns:
true if the organization is associated with the user; false otherwise

containsOrganizations

public static boolean containsOrganizations(long pk)
Returns true if the user has any organizations associated with it.

Parameters:
pk - the primary key of the user to check for associations with organizations
Returns:
true if the user has any organizations associated with it; false otherwise

addOrganization

public static void addOrganization(long pk,
                                   long organizationPK)
Adds an association between the user and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
organizationPK - the primary key of the organization

addOrganization

public static void addOrganization(long pk,
                                   Organization organization)
Adds an association between the user and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
organization - the organization

addOrganizations

public static void addOrganizations(long pk,
                                    long[] organizationPKs)
Adds an association between the user and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
organizationPKs - the primary keys of the organizations

addOrganizations

public static void addOrganizations(long pk,
                                    List<Organization> organizations)
Adds an association between the user and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
organizations - the organizations

clearOrganizations

public static void clearOrganizations(long pk)
Clears all associations between the user and its organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user to clear the associated organizations from

removeOrganization

public static void removeOrganization(long pk,
                                      long organizationPK)
Removes the association between the user and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
organizationPK - the primary key of the organization

removeOrganization

public static void removeOrganization(long pk,
                                      Organization organization)
Removes the association between the user and the organization. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
organization - the organization

removeOrganizations

public static void removeOrganizations(long pk,
                                       long[] organizationPKs)
Removes the association between the user and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
organizationPKs - the primary keys of the organizations

removeOrganizations

public static void removeOrganizations(long pk,
                                       List<Organization> organizations)
Removes the association between the user and the organizations. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
organizations - the organizations

setOrganizations

public static void setOrganizations(long pk,
                                    long[] organizationPKs)
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.

Parameters:
pk - the primary key of the user
organizationPKs - the primary keys of the organizations to be associated with the user

setOrganizations

public static void setOrganizations(long pk,
                                    List<Organization> organizations)
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.

Parameters:
pk - the primary key of the user
organizations - the organizations to be associated with the user

getRolePrimaryKeys

public static long[] getRolePrimaryKeys(long pk)
Returns the primaryKeys of roles associated with the user.

Parameters:
pk - the primary key of the user
Returns:
long[] of the primaryKeys of roles associated with the user

getRoles

public static List<Role> getRoles(long pk)
Returns all the roles associated with the user.

Parameters:
pk - the primary key of the user
Returns:
the roles associated with the user

getRoles

public static List<Role> getRoles(long pk,
                                  int start,
                                  int end)
Returns a range of all the roles associated with the user.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
pk - the primary key of the user
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
Returns:
the range of roles associated with the user

getRoles

public static List<Role> getRoles(long pk,
                                  int start,
                                  int end,
                                  OrderByComparator<Role> orderByComparator)
Returns an ordered range of all the roles associated with the user.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
pk - the primary key of the user
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
orderByComparator - the comparator to order the results by (optionally null)
Returns:
the ordered range of roles associated with the user

getRolesSize

public static int getRolesSize(long pk)
Returns the number of roles associated with the user.

Parameters:
pk - the primary key of the user
Returns:
the number of roles associated with the user

containsRole

public static boolean containsRole(long pk,
                                   long rolePK)
Returns true if the role is associated with the user.

Parameters:
pk - the primary key of the user
rolePK - the primary key of the role
Returns:
true if the role is associated with the user; false otherwise

containsRoles

public static boolean containsRoles(long pk)
Returns true if the user has any roles associated with it.

Parameters:
pk - the primary key of the user to check for associations with roles
Returns:
true if the user has any roles associated with it; false otherwise

addRole

public static void addRole(long pk,
                           long rolePK)
Adds an association between the user and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
rolePK - the primary key of the role

addRole

public static void addRole(long pk,
                           Role role)
Adds an association between the user and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
role - the role

addRoles

public static void addRoles(long pk,
                            long[] rolePKs)
Adds an association between the user and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
rolePKs - the primary keys of the roles

addRoles

public static void addRoles(long pk,
                            List<Role> roles)
Adds an association between the user and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
roles - the roles

clearRoles

public static void clearRoles(long pk)
Clears all associations between the user and its roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user to clear the associated roles from

removeRole

public static void removeRole(long pk,
                              long rolePK)
Removes the association between the user and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
rolePK - the primary key of the role

removeRole

public static void removeRole(long pk,
                              Role role)
Removes the association between the user and the role. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
role - the role

removeRoles

public static void removeRoles(long pk,
                               long[] rolePKs)
Removes the association between the user and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
rolePKs - the primary keys of the roles

removeRoles

public static void removeRoles(long pk,
                               List<Role> roles)
Removes the association between the user and the roles. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
roles - the roles

setRoles

public static void setRoles(long pk,
                            long[] rolePKs)
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.

Parameters:
pk - the primary key of the user
rolePKs - the primary keys of the roles to be associated with the user

setRoles

public static void setRoles(long pk,
                            List<Role> roles)
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.

Parameters:
pk - the primary key of the user
roles - the roles to be associated with the user

getTeamPrimaryKeys

public static long[] getTeamPrimaryKeys(long pk)
Returns the primaryKeys of teams associated with the user.

Parameters:
pk - the primary key of the user
Returns:
long[] of the primaryKeys of teams associated with the user

getTeams

public static List<Team> getTeams(long pk)
Returns all the teams associated with the user.

Parameters:
pk - the primary key of the user
Returns:
the teams associated with the user

getTeams

public static List<Team> getTeams(long pk,
                                  int start,
                                  int end)
Returns a range of all the teams associated with the user.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
pk - the primary key of the user
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
Returns:
the range of teams associated with the user

getTeams

public static List<Team> getTeams(long pk,
                                  int start,
                                  int end,
                                  OrderByComparator<Team> orderByComparator)
Returns an ordered range of all the teams associated with the user.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
pk - the primary key of the user
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
orderByComparator - the comparator to order the results by (optionally null)
Returns:
the ordered range of teams associated with the user

getTeamsSize

public static int getTeamsSize(long pk)
Returns the number of teams associated with the user.

Parameters:
pk - the primary key of the user
Returns:
the number of teams associated with the user

containsTeam

public static boolean containsTeam(long pk,
                                   long teamPK)
Returns true if the team is associated with the user.

Parameters:
pk - the primary key of the user
teamPK - the primary key of the team
Returns:
true if the team is associated with the user; false otherwise

containsTeams

public static boolean containsTeams(long pk)
Returns true if the user has any teams associated with it.

Parameters:
pk - the primary key of the user to check for associations with teams
Returns:
true if the user has any teams associated with it; false otherwise

addTeam

public static void addTeam(long pk,
                           long teamPK)
Adds an association between the user and the team. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
teamPK - the primary key of the team

addTeam

public static void addTeam(long pk,
                           Team team)
Adds an association between the user and the team. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
team - the team

addTeams

public static void addTeams(long pk,
                            long[] teamPKs)
Adds an association between the user and the teams. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
teamPKs - the primary keys of the teams

addTeams

public static void addTeams(long pk,
                            List<Team> teams)
Adds an association between the user and the teams. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
teams - the teams

clearTeams

public static void clearTeams(long pk)
Clears all associations between the user and its teams. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user to clear the associated teams from

removeTeam

public static void removeTeam(long pk,
                              long teamPK)
Removes the association between the user and the team. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
teamPK - the primary key of the team

removeTeam

public static void removeTeam(long pk,
                              Team team)
Removes the association between the user and the team. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
team - the team

removeTeams

public static void removeTeams(long pk,
                               long[] teamPKs)
Removes the association between the user and the teams. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
teamPKs - the primary keys of the teams

removeTeams

public static void removeTeams(long pk,
                               List<Team> teams)
Removes the association between the user and the teams. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
teams - the teams

setTeams

public static void setTeams(long pk,
                            long[] teamPKs)
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.

Parameters:
pk - the primary key of the user
teamPKs - the primary keys of the teams to be associated with the user

setTeams

public static void setTeams(long pk,
                            List<Team> teams)
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.

Parameters:
pk - the primary key of the user
teams - the teams to be associated with the user

getUserGroupPrimaryKeys

public static long[] getUserGroupPrimaryKeys(long pk)
Returns the primaryKeys of user groups associated with the user.

Parameters:
pk - the primary key of the user
Returns:
long[] of the primaryKeys of user groups associated with the user

getUserGroups

public static List<UserGroup> getUserGroups(long pk)
Returns all the user groups associated with the user.

Parameters:
pk - the primary key of the user
Returns:
the user groups associated with the user

getUserGroups

public static List<UserGroup> getUserGroups(long pk,
                                            int start,
                                            int end)
Returns a range of all the user groups associated with the user.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
pk - the primary key of the user
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
Returns:
the range of user groups associated with the user

getUserGroups

public static List<UserGroup> getUserGroups(long pk,
                                            int start,
                                            int end,
                                            OrderByComparator<UserGroup> orderByComparator)
Returns an ordered range of all the user groups associated with the user.

Useful when paginating results. Returns a maximum of end - start instances. start and end are not primary keys, they are indexes in the result set. Thus, 0 refers to the first result in the set. Setting both start and end to QueryUtil#ALL_POS will return the full result set. If orderByComparator is specified, then the query will include the given ORDER BY logic. If orderByComparator is absent and pagination is required (start and end are not QueryUtil#ALL_POS), then the query will include the default ORDER BY logic from UserModelImpl. If both orderByComparator 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.

Parameters:
pk - the primary key of the user
start - the lower bound of the range of users
end - the upper bound of the range of users (not inclusive)
orderByComparator - the comparator to order the results by (optionally null)
Returns:
the ordered range of user groups associated with the user

getUserGroupsSize

public static int getUserGroupsSize(long pk)
Returns the number of user groups associated with the user.

Parameters:
pk - the primary key of the user
Returns:
the number of user groups associated with the user

containsUserGroup

public static boolean containsUserGroup(long pk,
                                        long userGroupPK)
Returns true if the user group is associated with the user.

Parameters:
pk - the primary key of the user
userGroupPK - the primary key of the user group
Returns:
true if the user group is associated with the user; false otherwise

containsUserGroups

public static boolean containsUserGroups(long pk)
Returns true if the user has any user groups associated with it.

Parameters:
pk - the primary key of the user to check for associations with user groups
Returns:
true if the user has any user groups associated with it; false otherwise

addUserGroup

public static void addUserGroup(long pk,
                                long userGroupPK)
Adds an association between the user and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
userGroupPK - the primary key of the user group

addUserGroup

public static void addUserGroup(long pk,
                                UserGroup userGroup)
Adds an association between the user and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
userGroup - the user group

addUserGroups

public static void addUserGroups(long pk,
                                 long[] userGroupPKs)
Adds an association between the user and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
userGroupPKs - the primary keys of the user groups

addUserGroups

public static void addUserGroups(long pk,
                                 List<UserGroup> userGroups)
Adds an association between the user and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
userGroups - the user groups

clearUserGroups

public static void clearUserGroups(long pk)
Clears all associations between the user and its user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user to clear the associated user groups from

removeUserGroup

public static void removeUserGroup(long pk,
                                   long userGroupPK)
Removes the association between the user and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
userGroupPK - the primary key of the user group

removeUserGroup

public static void removeUserGroup(long pk,
                                   UserGroup userGroup)
Removes the association between the user and the user group. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
userGroup - the user group

removeUserGroups

public static void removeUserGroups(long pk,
                                    long[] userGroupPKs)
Removes the association between the user and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
userGroupPKs - the primary keys of the user groups

removeUserGroups

public static void removeUserGroups(long pk,
                                    List<UserGroup> userGroups)
Removes the association between the user and the user groups. Also notifies the appropriate model listeners and clears the mapping table finder cache.

Parameters:
pk - the primary key of the user
userGroups - the user groups

setUserGroups

public static void setUserGroups(long pk,
                                 long[] userGroupPKs)
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.

Parameters:
pk - the primary key of the user
userGroupPKs - the primary keys of the user groups to be associated with the user

setUserGroups

public static void setUserGroups(long pk,
                                 List<UserGroup> userGroups)
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.

Parameters:
pk - the primary key of the user
userGroups - the user groups to be associated with the user

getBadColumnNames

public static Set<String> getBadColumnNames()

getPersistence

public static UserPersistence getPersistence()

Liferay 7.0-ce-b4