|
Liferay 7.0-ce-b4 | |||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||
java.lang.Objectcom.liferay.portal.service.persistence.TeamUtil
@ProviderType public class TeamUtil
The persistence utility for the team service. This utility wraps TeamPersistenceImpl 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
TeamPersistence,
TeamPersistenceImpl| Constructor Summary | |
|---|---|
TeamUtil()
|
|
| Method Summary | |
|---|---|
static void |
addUser(long pk,
long userPK)
Adds an association between the team and the user. |
static void |
addUser(long pk,
User user)
Adds an association between the team and the user. |
static void |
addUserGroup(long pk,
long userGroupPK)
Adds an association between the team and the user group. |
static void |
addUserGroup(long pk,
UserGroup userGroup)
Adds an association between the team and the user group. |
static void |
addUserGroups(long pk,
List<UserGroup> userGroups)
Adds an association between the team and the user groups. |
static void |
addUserGroups(long pk,
long[] userGroupPKs)
Adds an association between the team and the user groups. |
static void |
addUsers(long pk,
List<User> users)
Adds an association between the team and the users. |
static void |
addUsers(long pk,
long[] userPKs)
Adds an association between the team and the users. |
static void |
cacheResult(List<Team> teams)
Caches the teams in the entity cache if it is enabled. |
static void |
cacheResult(Team team)
Caches the team in the entity cache if it is enabled. |
static void |
clearCache()
|
static void |
clearCache(Team team)
|
static void |
clearUserGroups(long pk)
Clears all associations between the team and its user groups. |
static void |
clearUsers(long pk)
Clears all associations between the team and its users. |
static boolean |
containsUser(long pk,
long userPK)
Returns true if the user is associated with the team. |
static boolean |
containsUserGroup(long pk,
long userGroupPK)
Returns true if the user group is associated with the team. |
static boolean |
containsUserGroups(long pk)
Returns true if the team has any user groups associated with it. |
static boolean |
containsUsers(long pk)
Returns true if the team has any users associated with it. |
static int |
countAll()
Returns the number of teams. |
static int |
countByG_N(long groupId,
String name)
Returns the number of teams where groupId = ? and name = ?. |
static int |
countByGroupId(long groupId)
Returns the number of teams where groupId = ?. |
static int |
countByUuid_C(String uuid,
long companyId)
Returns the number of teams where uuid = ? and companyId = ?. |
static int |
countByUUID_G(String uuid,
long groupId)
Returns the number of teams where uuid = ? and groupId = ?. |
static int |
countByUuid(String uuid)
Returns the number of teams where uuid = ?. |
static long |
countWithDynamicQuery(DynamicQuery dynamicQuery)
|
static Team |
create(long teamId)
Creates a new team with the primary key. |
static Team |
fetchByG_N(long groupId,
String name)
Returns the team where groupId = ? and name = ? or returns null if it could not be found. |
static Team |
fetchByG_N(long groupId,
String name,
boolean retrieveFromCache)
Returns the team where groupId = ? and name = ? or returns null if it could not be found, optionally using the finder cache. |
static Team |
fetchByGroupId_First(long groupId,
OrderByComparator<Team> orderByComparator)
Returns the first team in the ordered set where groupId = ?. |
static Team |
fetchByGroupId_Last(long groupId,
OrderByComparator<Team> orderByComparator)
Returns the last team in the ordered set where groupId = ?. |
static Team |
fetchByPrimaryKey(long teamId)
Returns the team with the primary key or returns null if it could not be found. |
static Map<Serializable,Team> |
fetchByPrimaryKeys(Set<Serializable> primaryKeys)
|
static Team |
fetchByUuid_C_First(String uuid,
long companyId,
OrderByComparator<Team> orderByComparator)
Returns the first team in the ordered set where uuid = ? and companyId = ?. |
static Team |
fetchByUuid_C_Last(String uuid,
long companyId,
OrderByComparator<Team> orderByComparator)
Returns the last team in the ordered set where uuid = ? and companyId = ?. |
static Team |
fetchByUuid_First(String uuid,
OrderByComparator<Team> orderByComparator)
Returns the first team in the ordered set where uuid = ?. |
static Team |
fetchByUUID_G(String uuid,
long groupId)
Returns the team where uuid = ? and groupId = ? or returns null if it could not be found. |
static Team |
fetchByUUID_G(String uuid,
long groupId,
boolean retrieveFromCache)
Returns the team where uuid = ? and groupId = ? or returns null if it could not be found, optionally using the finder cache. |
static Team |
fetchByUuid_Last(String uuid,
OrderByComparator<Team> orderByComparator)
Returns the last team in the ordered set where uuid = ?. |
static int |
filterCountByGroupId(long groupId)
Returns the number of teams that the user has permission to view where groupId = ?. |
static Team[] |
filterFindByGroupId_PrevAndNext(long teamId,
long groupId,
OrderByComparator<Team> orderByComparator)
Returns the teams before and after the current team in the ordered set of teams that the user has permission to view where groupId = ?. |
static List<Team> |
filterFindByGroupId(long groupId)
Returns all the teams that the user has permission to view where groupId = ?. |
static List<Team> |
filterFindByGroupId(long groupId,
int start,
int end)
Returns a range of all the teams that the user has permission to view where groupId = ?. |
static List<Team> |
filterFindByGroupId(long groupId,
int start,
int end,
OrderByComparator<Team> orderByComparator)
Returns an ordered range of all the teams that the user has permissions to view where groupId = ?. |
static List<Team> |
findAll()
Returns all the teams. |
static List<Team> |
findAll(int start,
int end)
Returns a range of all the teams. |
static List<Team> |
findAll(int start,
int end,
OrderByComparator<Team> orderByComparator)
Returns an ordered range of all the teams. |
static List<Team> |
findAll(int start,
int end,
OrderByComparator<Team> orderByComparator,
boolean retrieveFromCache)
Returns an ordered range of all the teams. |
static Team |
findByG_N(long groupId,
String name)
Returns the team where groupId = ? and name = ? or throws a NoSuchTeamException if it could not be found. |
static Team |
findByGroupId_First(long groupId,
OrderByComparator<Team> orderByComparator)
Returns the first team in the ordered set where groupId = ?. |
static Team |
findByGroupId_Last(long groupId,
OrderByComparator<Team> orderByComparator)
Returns the last team in the ordered set where groupId = ?. |
static Team[] |
findByGroupId_PrevAndNext(long teamId,
long groupId,
OrderByComparator<Team> orderByComparator)
Returns the teams before and after the current team in the ordered set where groupId = ?. |
static List<Team> |
findByGroupId(long groupId)
Returns all the teams where groupId = ?. |
static List<Team> |
findByGroupId(long groupId,
int start,
int end)
Returns a range of all the teams where groupId = ?. |
static List<Team> |
findByGroupId(long groupId,
int start,
int end,
OrderByComparator<Team> orderByComparator)
Returns an ordered range of all the teams where groupId = ?. |
static List<Team> |
findByGroupId(long groupId,
int start,
int end,
OrderByComparator<Team> orderByComparator,
boolean retrieveFromCache)
Returns an ordered range of all the teams where groupId = ?. |
static Team |
findByPrimaryKey(long teamId)
Returns the team with the primary key or throws a NoSuchTeamException if it could not be found. |
static Team |
findByUuid_C_First(String uuid,
long companyId,
OrderByComparator<Team> orderByComparator)
Returns the first team in the ordered set where uuid = ? and companyId = ?. |
static Team |
findByUuid_C_Last(String uuid,
long companyId,
OrderByComparator<Team> orderByComparator)
Returns the last team in the ordered set where uuid = ? and companyId = ?. |
static Team[] |
findByUuid_C_PrevAndNext(long teamId,
String uuid,
long companyId,
OrderByComparator<Team> orderByComparator)
Returns the teams before and after the current team in the ordered set where uuid = ? and companyId = ?. |
static List<Team> |
findByUuid_C(String uuid,
long companyId)
Returns all the teams where uuid = ? and companyId = ?. |
static List<Team> |
findByUuid_C(String uuid,
long companyId,
int start,
int end)
Returns a range of all the teams where uuid = ? and companyId = ?. |
static List<Team> |
findByUuid_C(String uuid,
long companyId,
int start,
int end,
OrderByComparator<Team> orderByComparator)
Returns an ordered range of all the teams where uuid = ? and companyId = ?. |
static List<Team> |
findByUuid_C(String uuid,
long companyId,
int start,
int end,
OrderByComparator<Team> orderByComparator,
boolean retrieveFromCache)
Returns an ordered range of all the teams where uuid = ? and companyId = ?. |
static Team |
findByUuid_First(String uuid,
OrderByComparator<Team> orderByComparator)
Returns the first team in the ordered set where uuid = ?. |
static Team |
findByUUID_G(String uuid,
long groupId)
Returns the team where uuid = ? and groupId = ? or throws a NoSuchTeamException if it could not be found. |
static Team |
findByUuid_Last(String uuid,
OrderByComparator<Team> orderByComparator)
Returns the last team in the ordered set where uuid = ?. |
static Team[] |
findByUuid_PrevAndNext(long teamId,
String uuid,
OrderByComparator<Team> orderByComparator)
Returns the teams before and after the current team in the ordered set where uuid = ?. |
static List<Team> |
findByUuid(String uuid)
Returns all the teams where uuid = ?. |
static List<Team> |
findByUuid(String uuid,
int start,
int end)
Returns a range of all the teams where uuid = ?. |
static List<Team> |
findByUuid(String uuid,
int start,
int end,
OrderByComparator<Team> orderByComparator)
Returns an ordered range of all the teams where uuid = ?. |
static List<Team> |
findByUuid(String uuid,
int start,
int end,
OrderByComparator<Team> orderByComparator,
boolean retrieveFromCache)
Returns an ordered range of all the teams where uuid = ?. |
static List<Team> |
findWithDynamicQuery(DynamicQuery dynamicQuery)
|
static List<Team> |
findWithDynamicQuery(DynamicQuery dynamicQuery,
int start,
int end)
|
static List<Team> |
findWithDynamicQuery(DynamicQuery dynamicQuery,
int start,
int end,
OrderByComparator<Team> orderByComparator)
|
static Set<String> |
getBadColumnNames()
|
static TeamPersistence |
getPersistence()
|
static long[] |
getUserGroupPrimaryKeys(long pk)
Returns the primaryKeys of user groups associated with the team. |
static List<UserGroup> |
getUserGroups(long pk)
Returns all the user groups associated with the team. |
static List<UserGroup> |
getUserGroups(long pk,
int start,
int end)
Returns a range of all the user groups associated with the team. |
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 team. |
static int |
getUserGroupsSize(long pk)
Returns the number of user groups associated with the team. |
static long[] |
getUserPrimaryKeys(long pk)
Returns the primaryKeys of users associated with the team. |
static List<User> |
getUsers(long pk)
Returns all the users associated with the team. |
static List<User> |
getUsers(long pk,
int start,
int end)
Returns a range of all the users associated with the team. |
static List<User> |
getUsers(long pk,
int start,
int end,
OrderByComparator<User> orderByComparator)
Returns an ordered range of all the users associated with the team. |
static int |
getUsersSize(long pk)
Returns the number of users associated with the team. |
static Team |
remove(long teamId)
Removes the team with the primary key from the database. |
static void |
removeAll()
Removes all the teams from the database. |
static Team |
removeByG_N(long groupId,
String name)
Removes the team where groupId = ? and name = ? from the database. |
static void |
removeByGroupId(long groupId)
Removes all the teams where groupId = ? from the database. |
static void |
removeByUuid_C(String uuid,
long companyId)
Removes all the teams where uuid = ? and companyId = ? from the database. |
static Team |
removeByUUID_G(String uuid,
long groupId)
Removes the team where uuid = ? and groupId = ? from the database. |
static void |
removeByUuid(String uuid)
Removes all the teams where uuid = ? from the database. |
static void |
removeUser(long pk,
long userPK)
Removes the association between the team and the user. |
static void |
removeUser(long pk,
User user)
Removes the association between the team and the user. |
static void |
removeUserGroup(long pk,
long userGroupPK)
Removes the association between the team and the user group. |
static void |
removeUserGroup(long pk,
UserGroup userGroup)
Removes the association between the team and the user group. |
static void |
removeUserGroups(long pk,
List<UserGroup> userGroups)
Removes the association between the team and the user groups. |
static void |
removeUserGroups(long pk,
long[] userGroupPKs)
Removes the association between the team and the user groups. |
static void |
removeUsers(long pk,
List<User> users)
Removes the association between the team and the users. |
static void |
removeUsers(long pk,
long[] userPKs)
Removes the association between the team and the users. |
static void |
setUserGroups(long pk,
List<UserGroup> userGroups)
Sets the user groups associated with the team, removing and adding associations as necessary. |
static void |
setUserGroups(long pk,
long[] userGroupPKs)
Sets the user groups associated with the team, removing and adding associations as necessary. |
static void |
setUsers(long pk,
List<User> users)
Sets the users associated with the team, removing and adding associations as necessary. |
static void |
setUsers(long pk,
long[] userPKs)
Sets the users associated with the team, removing and adding associations as necessary. |
static Team |
update(Team team)
|
static Team |
update(Team team,
ServiceContext serviceContext)
|
static Team |
updateImpl(Team team)
|
| Methods inherited from class java.lang.Object |
|---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Constructor Detail |
|---|
public TeamUtil()
| Method Detail |
|---|
public static void clearCache()
BasePersistence.clearCache()public static void clearCache(Team team)
BasePersistence.clearCache(com.liferay.portal.model.BaseModel)public static long countWithDynamicQuery(DynamicQuery dynamicQuery)
BasePersistence.countWithDynamicQuery(DynamicQuery)public static List<Team> findWithDynamicQuery(DynamicQuery dynamicQuery)
BasePersistence.findWithDynamicQuery(DynamicQuery)
public static List<Team> findWithDynamicQuery(DynamicQuery dynamicQuery,
int start,
int end)
BasePersistence.findWithDynamicQuery(DynamicQuery, int, int)
public static List<Team> findWithDynamicQuery(DynamicQuery dynamicQuery,
int start,
int end,
OrderByComparator<Team> orderByComparator)
BasePersistence.findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)public static Team update(Team team)
BasePersistence.update(com.liferay.portal.model.BaseModel)
public static Team update(Team team,
ServiceContext serviceContext)
BasePersistence.update(com.liferay.portal.model.BaseModel, ServiceContext)public static List<Team> findByUuid(String uuid)
uuid - the uuid
public static List<Team> findByUuid(String uuid,
int start,
int end)
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 TeamModelImpl. 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.
uuid - the uuidstart - the lower bound of the range of teamsend - the upper bound of the range of teams (not inclusive)
public static List<Team> findByUuid(String uuid,
int start,
int end,
OrderByComparator<Team> orderByComparator)
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 TeamModelImpl. 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.
uuid - the uuidstart - the lower bound of the range of teamsend - the upper bound of the range of teams (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static List<Team> findByUuid(String uuid,
int start,
int end,
OrderByComparator<Team> orderByComparator,
boolean retrieveFromCache)
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 TeamModelImpl. 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.
uuid - the uuidstart - the lower bound of the range of teamsend - the upper bound of the range of teams (not inclusive)orderByComparator - the comparator to order the results by (optionally null)retrieveFromCache - whether to retrieve from the finder cache
public static Team findByUuid_First(String uuid,
OrderByComparator<Team> orderByComparator)
throws NoSuchTeamException
uuid - the uuidorderByComparator - the comparator to order the set by (optionally null)
NoSuchTeamException - if a matching team could not be found
public static Team fetchByUuid_First(String uuid,
OrderByComparator<Team> orderByComparator)
uuid - the uuidorderByComparator - the comparator to order the set by (optionally null)
null if a matching team could not be found
public static Team findByUuid_Last(String uuid,
OrderByComparator<Team> orderByComparator)
throws NoSuchTeamException
uuid - the uuidorderByComparator - the comparator to order the set by (optionally null)
NoSuchTeamException - if a matching team could not be found
public static Team fetchByUuid_Last(String uuid,
OrderByComparator<Team> orderByComparator)
uuid - the uuidorderByComparator - the comparator to order the set by (optionally null)
null if a matching team could not be found
public static Team[] findByUuid_PrevAndNext(long teamId,
String uuid,
OrderByComparator<Team> orderByComparator)
throws NoSuchTeamException
teamId - the primary key of the current teamuuid - the uuidorderByComparator - the comparator to order the set by (optionally null)
NoSuchTeamException - if a team with the primary key could not be foundpublic static void removeByUuid(String uuid)
uuid - the uuidpublic static int countByUuid(String uuid)
uuid - the uuid
public static Team findByUUID_G(String uuid,
long groupId)
throws NoSuchTeamException
NoSuchTeamException if it could not be found.
uuid - the uuidgroupId - the group ID
NoSuchTeamException - if a matching team could not be found
public static Team fetchByUUID_G(String uuid,
long groupId)
null if it could not be found. Uses the finder cache.
uuid - the uuidgroupId - the group ID
null if a matching team could not be found
public static Team fetchByUUID_G(String uuid,
long groupId,
boolean retrieveFromCache)
null if it could not be found, optionally using the finder cache.
uuid - the uuidgroupId - the group IDretrieveFromCache - whether to retrieve from the finder cache
null if a matching team could not be found
public static Team removeByUUID_G(String uuid,
long groupId)
throws NoSuchTeamException
uuid - the uuidgroupId - the group ID
NoSuchTeamException
public static int countByUUID_G(String uuid,
long groupId)
uuid - the uuidgroupId - the group ID
public static List<Team> findByUuid_C(String uuid,
long companyId)
uuid - the uuidcompanyId - the company ID
public static List<Team> findByUuid_C(String uuid,
long companyId,
int start,
int end)
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 TeamModelImpl. 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.
uuid - the uuidcompanyId - the company IDstart - the lower bound of the range of teamsend - the upper bound of the range of teams (not inclusive)
public static List<Team> findByUuid_C(String uuid,
long companyId,
int start,
int end,
OrderByComparator<Team> orderByComparator)
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 TeamModelImpl. 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.
uuid - the uuidcompanyId - the company IDstart - the lower bound of the range of teamsend - the upper bound of the range of teams (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static List<Team> findByUuid_C(String uuid,
long companyId,
int start,
int end,
OrderByComparator<Team> orderByComparator,
boolean retrieveFromCache)
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 TeamModelImpl. 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.
uuid - the uuidcompanyId - the company IDstart - the lower bound of the range of teamsend - the upper bound of the range of teams (not inclusive)orderByComparator - the comparator to order the results by (optionally null)retrieveFromCache - whether to retrieve from the finder cache
public static Team findByUuid_C_First(String uuid,
long companyId,
OrderByComparator<Team> orderByComparator)
throws NoSuchTeamException
uuid - the uuidcompanyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchTeamException - if a matching team could not be found
public static Team fetchByUuid_C_First(String uuid,
long companyId,
OrderByComparator<Team> orderByComparator)
uuid - the uuidcompanyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
null if a matching team could not be found
public static Team findByUuid_C_Last(String uuid,
long companyId,
OrderByComparator<Team> orderByComparator)
throws NoSuchTeamException
uuid - the uuidcompanyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchTeamException - if a matching team could not be found
public static Team fetchByUuid_C_Last(String uuid,
long companyId,
OrderByComparator<Team> orderByComparator)
uuid - the uuidcompanyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
null if a matching team could not be found
public static Team[] findByUuid_C_PrevAndNext(long teamId,
String uuid,
long companyId,
OrderByComparator<Team> orderByComparator)
throws NoSuchTeamException
teamId - the primary key of the current teamuuid - the uuidcompanyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchTeamException - if a team with the primary key could not be found
public static void removeByUuid_C(String uuid,
long companyId)
uuid - the uuidcompanyId - the company ID
public static int countByUuid_C(String uuid,
long companyId)
uuid - the uuidcompanyId - the company ID
public static List<Team> findByGroupId(long groupId)
groupId - the group ID
public static List<Team> findByGroupId(long groupId,
int start,
int end)
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 TeamModelImpl. 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.
groupId - the group IDstart - the lower bound of the range of teamsend - the upper bound of the range of teams (not inclusive)
public static List<Team> findByGroupId(long groupId,
int start,
int end,
OrderByComparator<Team> orderByComparator)
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 TeamModelImpl. 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.
groupId - the group IDstart - the lower bound of the range of teamsend - the upper bound of the range of teams (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static List<Team> findByGroupId(long groupId,
int start,
int end,
OrderByComparator<Team> orderByComparator,
boolean retrieveFromCache)
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 TeamModelImpl. 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.
groupId - the group IDstart - the lower bound of the range of teamsend - the upper bound of the range of teams (not inclusive)orderByComparator - the comparator to order the results by (optionally null)retrieveFromCache - whether to retrieve from the finder cache
public static Team findByGroupId_First(long groupId,
OrderByComparator<Team> orderByComparator)
throws NoSuchTeamException
groupId - the group IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchTeamException - if a matching team could not be found
public static Team fetchByGroupId_First(long groupId,
OrderByComparator<Team> orderByComparator)
groupId - the group IDorderByComparator - the comparator to order the set by (optionally null)
null if a matching team could not be found
public static Team findByGroupId_Last(long groupId,
OrderByComparator<Team> orderByComparator)
throws NoSuchTeamException
groupId - the group IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchTeamException - if a matching team could not be found
public static Team fetchByGroupId_Last(long groupId,
OrderByComparator<Team> orderByComparator)
groupId - the group IDorderByComparator - the comparator to order the set by (optionally null)
null if a matching team could not be found
public static Team[] findByGroupId_PrevAndNext(long teamId,
long groupId,
OrderByComparator<Team> orderByComparator)
throws NoSuchTeamException
teamId - the primary key of the current teamgroupId - the group IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchTeamException - if a team with the primary key could not be foundpublic static List<Team> filterFindByGroupId(long groupId)
groupId - the group ID
public static List<Team> filterFindByGroupId(long groupId,
int start,
int end)
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 TeamModelImpl. 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.
groupId - the group IDstart - the lower bound of the range of teamsend - the upper bound of the range of teams (not inclusive)
public static List<Team> filterFindByGroupId(long groupId,
int start,
int end,
OrderByComparator<Team> orderByComparator)
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 TeamModelImpl. 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.
groupId - the group IDstart - the lower bound of the range of teamsend - the upper bound of the range of teams (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static Team[] filterFindByGroupId_PrevAndNext(long teamId,
long groupId,
OrderByComparator<Team> orderByComparator)
throws NoSuchTeamException
teamId - the primary key of the current teamgroupId - the group IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchTeamException - if a team with the primary key could not be foundpublic static void removeByGroupId(long groupId)
groupId - the group IDpublic static int countByGroupId(long groupId)
groupId - the group ID
public static int filterCountByGroupId(long groupId)
groupId - the group ID
public static Team findByG_N(long groupId,
String name)
throws NoSuchTeamException
NoSuchTeamException if it could not be found.
groupId - the group IDname - the name
NoSuchTeamException - if a matching team could not be found
public static Team fetchByG_N(long groupId,
String name)
null if it could not be found. Uses the finder cache.
groupId - the group IDname - the name
null if a matching team could not be found
public static Team fetchByG_N(long groupId,
String name,
boolean retrieveFromCache)
null if it could not be found, optionally using the finder cache.
groupId - the group IDname - the nameretrieveFromCache - whether to retrieve from the finder cache
null if a matching team could not be found
public static Team removeByG_N(long groupId,
String name)
throws NoSuchTeamException
groupId - the group IDname - the name
NoSuchTeamException
public static int countByG_N(long groupId,
String name)
groupId - the group IDname - the name
public static void cacheResult(Team team)
team - the teampublic static void cacheResult(List<Team> teams)
teams - the teamspublic static Team create(long teamId)
teamId - the primary key for the new team
public static Team remove(long teamId)
throws NoSuchTeamException
teamId - the primary key of the team
NoSuchTeamException - if a team with the primary key could not be foundpublic static Team updateImpl(Team team)
public static Team findByPrimaryKey(long teamId)
throws NoSuchTeamException
NoSuchTeamException if it could not be found.
teamId - the primary key of the team
NoSuchTeamException - if a team with the primary key could not be foundpublic static Team fetchByPrimaryKey(long teamId)
null if it could not be found.
teamId - the primary key of the team
null if a team with the primary key could not be foundpublic static Map<Serializable,Team> fetchByPrimaryKeys(Set<Serializable> primaryKeys)
public static List<Team> findAll()
public static List<Team> findAll(int start,
int end)
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 TeamModelImpl. 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.
start - the lower bound of the range of teamsend - the upper bound of the range of teams (not inclusive)
public static List<Team> findAll(int start,
int end,
OrderByComparator<Team> orderByComparator)
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 TeamModelImpl. 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.
start - the lower bound of the range of teamsend - the upper bound of the range of teams (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static List<Team> findAll(int start,
int end,
OrderByComparator<Team> orderByComparator,
boolean retrieveFromCache)
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 TeamModelImpl. 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.
start - the lower bound of the range of teamsend - the upper bound of the range of teams (not inclusive)orderByComparator - the comparator to order the results by (optionally null)retrieveFromCache - whether to retrieve from the finder cache
public static void removeAll()
public static int countAll()
public static long[] getUserPrimaryKeys(long pk)
pk - the primary key of the team
public static List<User> getUsers(long pk)
pk - the primary key of the team
public static List<User> getUsers(long pk,
int start,
int end)
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 TeamModelImpl. 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.
pk - the primary key of the teamstart - the lower bound of the range of teamsend - the upper bound of the range of teams (not inclusive)
public static List<User> getUsers(long pk,
int start,
int end,
OrderByComparator<User> orderByComparator)
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 TeamModelImpl. 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.
pk - the primary key of the teamstart - the lower bound of the range of teamsend - the upper bound of the range of teams (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static int getUsersSize(long pk)
pk - the primary key of the team
public static boolean containsUser(long pk,
long userPK)
true if the user is associated with the team.
pk - the primary key of the teamuserPK - the primary key of the user
true if the user is associated with the team; false otherwisepublic static boolean containsUsers(long pk)
true if the team has any users associated with it.
pk - the primary key of the team to check for associations with users
true if the team has any users associated with it; false otherwise
public static void addUser(long pk,
long userPK)
pk - the primary key of the teamuserPK - the primary key of the user
public static void addUser(long pk,
User user)
pk - the primary key of the teamuser - the user
public static void addUsers(long pk,
long[] userPKs)
pk - the primary key of the teamuserPKs - the primary keys of the users
public static void addUsers(long pk,
List<User> users)
pk - the primary key of the teamusers - the userspublic static void clearUsers(long pk)
pk - the primary key of the team to clear the associated users from
public static void removeUser(long pk,
long userPK)
pk - the primary key of the teamuserPK - the primary key of the user
public static void removeUser(long pk,
User user)
pk - the primary key of the teamuser - the user
public static void removeUsers(long pk,
long[] userPKs)
pk - the primary key of the teamuserPKs - the primary keys of the users
public static void removeUsers(long pk,
List<User> users)
pk - the primary key of the teamusers - the users
public static void setUsers(long pk,
long[] userPKs)
pk - the primary key of the teamuserPKs - the primary keys of the users to be associated with the team
public static void setUsers(long pk,
List<User> users)
pk - the primary key of the teamusers - the users to be associated with the teampublic static long[] getUserGroupPrimaryKeys(long pk)
pk - the primary key of the team
public static List<UserGroup> getUserGroups(long pk)
pk - the primary key of the team
public static List<UserGroup> getUserGroups(long pk,
int start,
int end)
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 TeamModelImpl. 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.
pk - the primary key of the teamstart - the lower bound of the range of teamsend - the upper bound of the range of teams (not inclusive)
public static List<UserGroup> getUserGroups(long pk,
int start,
int end,
OrderByComparator<UserGroup> orderByComparator)
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 TeamModelImpl. 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.
pk - the primary key of the teamstart - the lower bound of the range of teamsend - the upper bound of the range of teams (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static int getUserGroupsSize(long pk)
pk - the primary key of the team
public static boolean containsUserGroup(long pk,
long userGroupPK)
true if the user group is associated with the team.
pk - the primary key of the teamuserGroupPK - the primary key of the user group
true if the user group is associated with the team; false otherwisepublic static boolean containsUserGroups(long pk)
true if the team has any user groups associated with it.
pk - the primary key of the team to check for associations with user groups
true if the team has any user groups associated with it; false otherwise
public static void addUserGroup(long pk,
long userGroupPK)
pk - the primary key of the teamuserGroupPK - the primary key of the user group
public static void addUserGroup(long pk,
UserGroup userGroup)
pk - the primary key of the teamuserGroup - the user group
public static void addUserGroups(long pk,
long[] userGroupPKs)
pk - the primary key of the teamuserGroupPKs - the primary keys of the user groups
public static void addUserGroups(long pk,
List<UserGroup> userGroups)
pk - the primary key of the teamuserGroups - the user groupspublic static void clearUserGroups(long pk)
pk - the primary key of the team to clear the associated user groups from
public static void removeUserGroup(long pk,
long userGroupPK)
pk - the primary key of the teamuserGroupPK - the primary key of the user group
public static void removeUserGroup(long pk,
UserGroup userGroup)
pk - the primary key of the teamuserGroup - the user group
public static void removeUserGroups(long pk,
long[] userGroupPKs)
pk - the primary key of the teamuserGroupPKs - the primary keys of the user groups
public static void removeUserGroups(long pk,
List<UserGroup> userGroups)
pk - the primary key of the teamuserGroups - the user groups
public static void setUserGroups(long pk,
long[] userGroupPKs)
pk - the primary key of the teamuserGroupPKs - the primary keys of the user groups to be associated with the team
public static void setUserGroups(long pk,
List<UserGroup> userGroups)
pk - the primary key of the teamuserGroups - the user groups to be associated with the teampublic static Set<String> getBadColumnNames()
public static TeamPersistence getPersistence()
|
Liferay 7.0-ce-b4 | |||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||