|
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.RoleUtil
@ProviderType public class RoleUtil
The persistence utility for the role service. This utility wraps RolePersistenceImpl 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
RolePersistence,
RolePersistenceImpl| Constructor Summary | |
|---|---|
RoleUtil()
|
|
| Method Summary | |
|---|---|
static void |
addGroup(long pk,
Group group)
Adds an association between the role and the group. |
static void |
addGroup(long pk,
long groupPK)
Adds an association between the role and the group. |
static void |
addGroups(long pk,
List<Group> groups)
Adds an association between the role and the groups. |
static void |
addGroups(long pk,
long[] groupPKs)
Adds an association between the role and the groups. |
static void |
addUser(long pk,
long userPK)
Adds an association between the role and the user. |
static void |
addUser(long pk,
User user)
Adds an association between the role and the user. |
static void |
addUsers(long pk,
List<User> users)
Adds an association between the role and the users. |
static void |
addUsers(long pk,
long[] userPKs)
Adds an association between the role and the users. |
static void |
cacheResult(List<Role> roles)
Caches the roles in the entity cache if it is enabled. |
static void |
cacheResult(Role role)
Caches the role in the entity cache if it is enabled. |
static void |
clearCache()
|
static void |
clearCache(Role role)
|
static void |
clearGroups(long pk)
Clears all associations between the role and its groups. |
static void |
clearUsers(long pk)
Clears all associations between the role and its users. |
static boolean |
containsGroup(long pk,
long groupPK)
Returns true if the group is associated with the role. |
static boolean |
containsGroups(long pk)
Returns true if the role has any groups associated with it. |
static boolean |
containsUser(long pk,
long userPK)
Returns true if the user is associated with the role. |
static boolean |
containsUsers(long pk)
Returns true if the role has any users associated with it. |
static int |
countAll()
Returns the number of roles. |
static int |
countByC_C_C(long companyId,
long classNameId,
long classPK)
Returns the number of roles where companyId = ? and classNameId = ? and classPK = ?. |
static int |
countByC_N(long companyId,
String name)
Returns the number of roles where companyId = ? and name = ?. |
static int |
countByC_T(long companyId,
int type)
Returns the number of roles where companyId = ? and type = ?. |
static int |
countByC_T(long companyId,
int[] types)
Returns the number of roles where companyId = ? and type = any ?. |
static int |
countByCompanyId(long companyId)
Returns the number of roles where companyId = ?. |
static int |
countByName(String name)
Returns the number of roles where name = ?. |
static int |
countBySubtype(String subtype)
Returns the number of roles where subtype = ?. |
static int |
countByT_S(int type,
String subtype)
Returns the number of roles where type = ? and subtype = ?. |
static int |
countByType(int type)
Returns the number of roles where type = ?. |
static int |
countByUuid_C(String uuid,
long companyId)
Returns the number of roles where uuid = ? and companyId = ?. |
static int |
countByUuid(String uuid)
Returns the number of roles where uuid = ?. |
static long |
countWithDynamicQuery(DynamicQuery dynamicQuery)
|
static Role |
create(long roleId)
Creates a new role with the primary key. |
static Role |
fetchByC_C_C(long companyId,
long classNameId,
long classPK)
Returns the role where companyId = ? and classNameId = ? and classPK = ? or returns null if it could not be found. |
static Role |
fetchByC_C_C(long companyId,
long classNameId,
long classPK,
boolean retrieveFromCache)
Returns the role where companyId = ? and classNameId = ? and classPK = ? or returns null if it could not be found, optionally using the finder cache. |
static Role |
fetchByC_N(long companyId,
String name)
Returns the role where companyId = ? and name = ? or returns null if it could not be found. |
static Role |
fetchByC_N(long companyId,
String name,
boolean retrieveFromCache)
Returns the role where companyId = ? and name = ? or returns null if it could not be found, optionally using the finder cache. |
static Role |
fetchByC_T_First(long companyId,
int type,
OrderByComparator<Role> orderByComparator)
Returns the first role in the ordered set where companyId = ? and type = ?. |
static Role |
fetchByC_T_Last(long companyId,
int type,
OrderByComparator<Role> orderByComparator)
Returns the last role in the ordered set where companyId = ? and type = ?. |
static Role |
fetchByCompanyId_First(long companyId,
OrderByComparator<Role> orderByComparator)
Returns the first role in the ordered set where companyId = ?. |
static Role |
fetchByCompanyId_Last(long companyId,
OrderByComparator<Role> orderByComparator)
Returns the last role in the ordered set where companyId = ?. |
static Role |
fetchByName_First(String name,
OrderByComparator<Role> orderByComparator)
Returns the first role in the ordered set where name = ?. |
static Role |
fetchByName_Last(String name,
OrderByComparator<Role> orderByComparator)
Returns the last role in the ordered set where name = ?. |
static Role |
fetchByPrimaryKey(long roleId)
Returns the role with the primary key or returns null if it could not be found. |
static Map<Serializable,Role> |
fetchByPrimaryKeys(Set<Serializable> primaryKeys)
|
static Role |
fetchBySubtype_First(String subtype,
OrderByComparator<Role> orderByComparator)
Returns the first role in the ordered set where subtype = ?. |
static Role |
fetchBySubtype_Last(String subtype,
OrderByComparator<Role> orderByComparator)
Returns the last role in the ordered set where subtype = ?. |
static Role |
fetchByT_S_First(int type,
String subtype,
OrderByComparator<Role> orderByComparator)
Returns the first role in the ordered set where type = ? and subtype = ?. |
static Role |
fetchByT_S_Last(int type,
String subtype,
OrderByComparator<Role> orderByComparator)
Returns the last role in the ordered set where type = ? and subtype = ?. |
static Role |
fetchByType_First(int type,
OrderByComparator<Role> orderByComparator)
Returns the first role in the ordered set where type = ?. |
static Role |
fetchByType_Last(int type,
OrderByComparator<Role> orderByComparator)
Returns the last role in the ordered set where type = ?. |
static Role |
fetchByUuid_C_First(String uuid,
long companyId,
OrderByComparator<Role> orderByComparator)
Returns the first role in the ordered set where uuid = ? and companyId = ?. |
static Role |
fetchByUuid_C_Last(String uuid,
long companyId,
OrderByComparator<Role> orderByComparator)
Returns the last role in the ordered set where uuid = ? and companyId = ?. |
static Role |
fetchByUuid_First(String uuid,
OrderByComparator<Role> orderByComparator)
Returns the first role in the ordered set where uuid = ?. |
static Role |
fetchByUuid_Last(String uuid,
OrderByComparator<Role> orderByComparator)
Returns the last role in the ordered set where uuid = ?. |
static int |
filterCountByC_T(long companyId,
int type)
Returns the number of roles that the user has permission to view where companyId = ? and type = ?. |
static int |
filterCountByC_T(long companyId,
int[] types)
Returns the number of roles that the user has permission to view where companyId = ? and type = any ?. |
static int |
filterCountByCompanyId(long companyId)
Returns the number of roles that the user has permission to view where companyId = ?. |
static int |
filterCountByName(String name)
Returns the number of roles that the user has permission to view where name = ?. |
static int |
filterCountBySubtype(String subtype)
Returns the number of roles that the user has permission to view where subtype = ?. |
static int |
filterCountByT_S(int type,
String subtype)
Returns the number of roles that the user has permission to view where type = ? and subtype = ?. |
static int |
filterCountByType(int type)
Returns the number of roles that the user has permission to view where type = ?. |
static int |
filterCountByUuid_C(String uuid,
long companyId)
Returns the number of roles that the user has permission to view where uuid = ? and companyId = ?. |
static int |
filterCountByUuid(String uuid)
Returns the number of roles that the user has permission to view where uuid = ?. |
static Role[] |
filterFindByC_T_PrevAndNext(long roleId,
long companyId,
int type,
OrderByComparator<Role> orderByComparator)
Returns the roles before and after the current role in the ordered set of roles that the user has permission to view where companyId = ? and type = ?. |
static List<Role> |
filterFindByC_T(long companyId,
int type)
Returns all the roles that the user has permission to view where companyId = ? and type = ?. |
static List<Role> |
filterFindByC_T(long companyId,
int[] types)
Returns all the roles that the user has permission to view where companyId = ? and type = any ?. |
static List<Role> |
filterFindByC_T(long companyId,
int[] types,
int start,
int end)
Returns a range of all the roles that the user has permission to view where companyId = ? and type = any ?. |
static List<Role> |
filterFindByC_T(long companyId,
int[] types,
int start,
int end,
OrderByComparator<Role> orderByComparator)
Returns an ordered range of all the roles that the user has permission to view where companyId = ? and type = any ?. |
static List<Role> |
filterFindByC_T(long companyId,
int type,
int start,
int end)
Returns a range of all the roles that the user has permission to view where companyId = ? and type = ?. |
static List<Role> |
filterFindByC_T(long companyId,
int type,
int start,
int end,
OrderByComparator<Role> orderByComparator)
Returns an ordered range of all the roles that the user has permissions to view where companyId = ? and type = ?. |
static Role[] |
filterFindByCompanyId_PrevAndNext(long roleId,
long companyId,
OrderByComparator<Role> orderByComparator)
Returns the roles before and after the current role in the ordered set of roles that the user has permission to view where companyId = ?. |
static List<Role> |
filterFindByCompanyId(long companyId)
Returns all the roles that the user has permission to view where companyId = ?. |
static List<Role> |
filterFindByCompanyId(long companyId,
int start,
int end)
Returns a range of all the roles that the user has permission to view where companyId = ?. |
static List<Role> |
filterFindByCompanyId(long companyId,
int start,
int end,
OrderByComparator<Role> orderByComparator)
Returns an ordered range of all the roles that the user has permissions to view where companyId = ?. |
static Role[] |
filterFindByName_PrevAndNext(long roleId,
String name,
OrderByComparator<Role> orderByComparator)
Returns the roles before and after the current role in the ordered set of roles that the user has permission to view where name = ?. |
static List<Role> |
filterFindByName(String name)
Returns all the roles that the user has permission to view where name = ?. |
static List<Role> |
filterFindByName(String name,
int start,
int end)
Returns a range of all the roles that the user has permission to view where name = ?. |
static List<Role> |
filterFindByName(String name,
int start,
int end,
OrderByComparator<Role> orderByComparator)
Returns an ordered range of all the roles that the user has permissions to view where name = ?. |
static Role[] |
filterFindBySubtype_PrevAndNext(long roleId,
String subtype,
OrderByComparator<Role> orderByComparator)
Returns the roles before and after the current role in the ordered set of roles that the user has permission to view where subtype = ?. |
static List<Role> |
filterFindBySubtype(String subtype)
Returns all the roles that the user has permission to view where subtype = ?. |
static List<Role> |
filterFindBySubtype(String subtype,
int start,
int end)
Returns a range of all the roles that the user has permission to view where subtype = ?. |
static List<Role> |
filterFindBySubtype(String subtype,
int start,
int end,
OrderByComparator<Role> orderByComparator)
Returns an ordered range of all the roles that the user has permissions to view where subtype = ?. |
static Role[] |
filterFindByT_S_PrevAndNext(long roleId,
int type,
String subtype,
OrderByComparator<Role> orderByComparator)
Returns the roles before and after the current role in the ordered set of roles that the user has permission to view where type = ? and subtype = ?. |
static List<Role> |
filterFindByT_S(int type,
String subtype)
Returns all the roles that the user has permission to view where type = ? and subtype = ?. |
static List<Role> |
filterFindByT_S(int type,
String subtype,
int start,
int end)
Returns a range of all the roles that the user has permission to view where type = ? and subtype = ?. |
static List<Role> |
filterFindByT_S(int type,
String subtype,
int start,
int end,
OrderByComparator<Role> orderByComparator)
Returns an ordered range of all the roles that the user has permissions to view where type = ? and subtype = ?. |
static Role[] |
filterFindByType_PrevAndNext(long roleId,
int type,
OrderByComparator<Role> orderByComparator)
Returns the roles before and after the current role in the ordered set of roles that the user has permission to view where type = ?. |
static List<Role> |
filterFindByType(int type)
Returns all the roles that the user has permission to view where type = ?. |
static List<Role> |
filterFindByType(int type,
int start,
int end)
Returns a range of all the roles that the user has permission to view where type = ?. |
static List<Role> |
filterFindByType(int type,
int start,
int end,
OrderByComparator<Role> orderByComparator)
Returns an ordered range of all the roles that the user has permissions to view where type = ?. |
static Role[] |
filterFindByUuid_C_PrevAndNext(long roleId,
String uuid,
long companyId,
OrderByComparator<Role> orderByComparator)
Returns the roles before and after the current role in the ordered set of roles that the user has permission to view where uuid = ? and companyId = ?. |
static List<Role> |
filterFindByUuid_C(String uuid,
long companyId)
Returns all the roles that the user has permission to view where uuid = ? and companyId = ?. |
static List<Role> |
filterFindByUuid_C(String uuid,
long companyId,
int start,
int end)
Returns a range of all the roles that the user has permission to view where uuid = ? and companyId = ?. |
static List<Role> |
filterFindByUuid_C(String uuid,
long companyId,
int start,
int end,
OrderByComparator<Role> orderByComparator)
Returns an ordered range of all the roles that the user has permissions to view where uuid = ? and companyId = ?. |
static Role[] |
filterFindByUuid_PrevAndNext(long roleId,
String uuid,
OrderByComparator<Role> orderByComparator)
Returns the roles before and after the current role in the ordered set of roles that the user has permission to view where uuid = ?. |
static List<Role> |
filterFindByUuid(String uuid)
Returns all the roles that the user has permission to view where uuid = ?. |
static List<Role> |
filterFindByUuid(String uuid,
int start,
int end)
Returns a range of all the roles that the user has permission to view where uuid = ?. |
static List<Role> |
filterFindByUuid(String uuid,
int start,
int end,
OrderByComparator<Role> orderByComparator)
Returns an ordered range of all the roles that the user has permissions to view where uuid = ?. |
static List<Role> |
findAll()
Returns all the roles. |
static List<Role> |
findAll(int start,
int end)
Returns a range of all the roles. |
static List<Role> |
findAll(int start,
int end,
OrderByComparator<Role> orderByComparator)
Returns an ordered range of all the roles. |
static List<Role> |
findAll(int start,
int end,
OrderByComparator<Role> orderByComparator,
boolean retrieveFromCache)
Returns an ordered range of all the roles. |
static Role |
findByC_C_C(long companyId,
long classNameId,
long classPK)
Returns the role where companyId = ? and classNameId = ? and classPK = ? or throws a NoSuchRoleException if it could not be found. |
static Role |
findByC_N(long companyId,
String name)
Returns the role where companyId = ? and name = ? or throws a NoSuchRoleException if it could not be found. |
static Role |
findByC_T_First(long companyId,
int type,
OrderByComparator<Role> orderByComparator)
Returns the first role in the ordered set where companyId = ? and type = ?. |
static Role |
findByC_T_Last(long companyId,
int type,
OrderByComparator<Role> orderByComparator)
Returns the last role in the ordered set where companyId = ? and type = ?. |
static Role[] |
findByC_T_PrevAndNext(long roleId,
long companyId,
int type,
OrderByComparator<Role> orderByComparator)
Returns the roles before and after the current role in the ordered set where companyId = ? and type = ?. |
static List<Role> |
findByC_T(long companyId,
int type)
Returns all the roles where companyId = ? and type = ?. |
static List<Role> |
findByC_T(long companyId,
int[] types)
Returns all the roles where companyId = ? and type = any ?. |
static List<Role> |
findByC_T(long companyId,
int[] types,
int start,
int end)
Returns a range of all the roles where companyId = ? and type = any ?. |
static List<Role> |
findByC_T(long companyId,
int[] types,
int start,
int end,
OrderByComparator<Role> orderByComparator)
Returns an ordered range of all the roles where companyId = ? and type = any ?. |
static List<Role> |
findByC_T(long companyId,
int[] types,
int start,
int end,
OrderByComparator<Role> orderByComparator,
boolean retrieveFromCache)
Returns an ordered range of all the roles where companyId = ? and type = ?, optionally using the finder cache. |
static List<Role> |
findByC_T(long companyId,
int type,
int start,
int end)
Returns a range of all the roles where companyId = ? and type = ?. |
static List<Role> |
findByC_T(long companyId,
int type,
int start,
int end,
OrderByComparator<Role> orderByComparator)
Returns an ordered range of all the roles where companyId = ? and type = ?. |
static List<Role> |
findByC_T(long companyId,
int type,
int start,
int end,
OrderByComparator<Role> orderByComparator,
boolean retrieveFromCache)
Returns an ordered range of all the roles where companyId = ? and type = ?. |
static Role |
findByCompanyId_First(long companyId,
OrderByComparator<Role> orderByComparator)
Returns the first role in the ordered set where companyId = ?. |
static Role |
findByCompanyId_Last(long companyId,
OrderByComparator<Role> orderByComparator)
Returns the last role in the ordered set where companyId = ?. |
static Role[] |
findByCompanyId_PrevAndNext(long roleId,
long companyId,
OrderByComparator<Role> orderByComparator)
Returns the roles before and after the current role in the ordered set where companyId = ?. |
static List<Role> |
findByCompanyId(long companyId)
Returns all the roles where companyId = ?. |
static List<Role> |
findByCompanyId(long companyId,
int start,
int end)
Returns a range of all the roles where companyId = ?. |
static List<Role> |
findByCompanyId(long companyId,
int start,
int end,
OrderByComparator<Role> orderByComparator)
Returns an ordered range of all the roles where companyId = ?. |
static List<Role> |
findByCompanyId(long companyId,
int start,
int end,
OrderByComparator<Role> orderByComparator,
boolean retrieveFromCache)
Returns an ordered range of all the roles where companyId = ?. |
static Role |
findByName_First(String name,
OrderByComparator<Role> orderByComparator)
Returns the first role in the ordered set where name = ?. |
static Role |
findByName_Last(String name,
OrderByComparator<Role> orderByComparator)
Returns the last role in the ordered set where name = ?. |
static Role[] |
findByName_PrevAndNext(long roleId,
String name,
OrderByComparator<Role> orderByComparator)
Returns the roles before and after the current role in the ordered set where name = ?. |
static List<Role> |
findByName(String name)
Returns all the roles where name = ?. |
static List<Role> |
findByName(String name,
int start,
int end)
Returns a range of all the roles where name = ?. |
static List<Role> |
findByName(String name,
int start,
int end,
OrderByComparator<Role> orderByComparator)
Returns an ordered range of all the roles where name = ?. |
static List<Role> |
findByName(String name,
int start,
int end,
OrderByComparator<Role> orderByComparator,
boolean retrieveFromCache)
Returns an ordered range of all the roles where name = ?. |
static Role |
findByPrimaryKey(long roleId)
Returns the role with the primary key or throws a NoSuchRoleException if it could not be found. |
static Role |
findBySubtype_First(String subtype,
OrderByComparator<Role> orderByComparator)
Returns the first role in the ordered set where subtype = ?. |
static Role |
findBySubtype_Last(String subtype,
OrderByComparator<Role> orderByComparator)
Returns the last role in the ordered set where subtype = ?. |
static Role[] |
findBySubtype_PrevAndNext(long roleId,
String subtype,
OrderByComparator<Role> orderByComparator)
Returns the roles before and after the current role in the ordered set where subtype = ?. |
static List<Role> |
findBySubtype(String subtype)
Returns all the roles where subtype = ?. |
static List<Role> |
findBySubtype(String subtype,
int start,
int end)
Returns a range of all the roles where subtype = ?. |
static List<Role> |
findBySubtype(String subtype,
int start,
int end,
OrderByComparator<Role> orderByComparator)
Returns an ordered range of all the roles where subtype = ?. |
static List<Role> |
findBySubtype(String subtype,
int start,
int end,
OrderByComparator<Role> orderByComparator,
boolean retrieveFromCache)
Returns an ordered range of all the roles where subtype = ?. |
static Role |
findByT_S_First(int type,
String subtype,
OrderByComparator<Role> orderByComparator)
Returns the first role in the ordered set where type = ? and subtype = ?. |
static Role |
findByT_S_Last(int type,
String subtype,
OrderByComparator<Role> orderByComparator)
Returns the last role in the ordered set where type = ? and subtype = ?. |
static Role[] |
findByT_S_PrevAndNext(long roleId,
int type,
String subtype,
OrderByComparator<Role> orderByComparator)
Returns the roles before and after the current role in the ordered set where type = ? and subtype = ?. |
static List<Role> |
findByT_S(int type,
String subtype)
Returns all the roles where type = ? and subtype = ?. |
static List<Role> |
findByT_S(int type,
String subtype,
int start,
int end)
Returns a range of all the roles where type = ? and subtype = ?. |
static List<Role> |
findByT_S(int type,
String subtype,
int start,
int end,
OrderByComparator<Role> orderByComparator)
Returns an ordered range of all the roles where type = ? and subtype = ?. |
static List<Role> |
findByT_S(int type,
String subtype,
int start,
int end,
OrderByComparator<Role> orderByComparator,
boolean retrieveFromCache)
Returns an ordered range of all the roles where type = ? and subtype = ?. |
static Role |
findByType_First(int type,
OrderByComparator<Role> orderByComparator)
Returns the first role in the ordered set where type = ?. |
static Role |
findByType_Last(int type,
OrderByComparator<Role> orderByComparator)
Returns the last role in the ordered set where type = ?. |
static Role[] |
findByType_PrevAndNext(long roleId,
int type,
OrderByComparator<Role> orderByComparator)
Returns the roles before and after the current role in the ordered set where type = ?. |
static List<Role> |
findByType(int type)
Returns all the roles where type = ?. |
static List<Role> |
findByType(int type,
int start,
int end)
Returns a range of all the roles where type = ?. |
static List<Role> |
findByType(int type,
int start,
int end,
OrderByComparator<Role> orderByComparator)
Returns an ordered range of all the roles where type = ?. |
static List<Role> |
findByType(int type,
int start,
int end,
OrderByComparator<Role> orderByComparator,
boolean retrieveFromCache)
Returns an ordered range of all the roles where type = ?. |
static Role |
findByUuid_C_First(String uuid,
long companyId,
OrderByComparator<Role> orderByComparator)
Returns the first role in the ordered set where uuid = ? and companyId = ?. |
static Role |
findByUuid_C_Last(String uuid,
long companyId,
OrderByComparator<Role> orderByComparator)
Returns the last role in the ordered set where uuid = ? and companyId = ?. |
static Role[] |
findByUuid_C_PrevAndNext(long roleId,
String uuid,
long companyId,
OrderByComparator<Role> orderByComparator)
Returns the roles before and after the current role in the ordered set where uuid = ? and companyId = ?. |
static List<Role> |
findByUuid_C(String uuid,
long companyId)
Returns all the roles where uuid = ? and companyId = ?. |
static List<Role> |
findByUuid_C(String uuid,
long companyId,
int start,
int end)
Returns a range of all the roles where uuid = ? and companyId = ?. |
static List<Role> |
findByUuid_C(String uuid,
long companyId,
int start,
int end,
OrderByComparator<Role> orderByComparator)
Returns an ordered range of all the roles where uuid = ? and companyId = ?. |
static List<Role> |
findByUuid_C(String uuid,
long companyId,
int start,
int end,
OrderByComparator<Role> orderByComparator,
boolean retrieveFromCache)
Returns an ordered range of all the roles where uuid = ? and companyId = ?. |
static Role |
findByUuid_First(String uuid,
OrderByComparator<Role> orderByComparator)
Returns the first role in the ordered set where uuid = ?. |
static Role |
findByUuid_Last(String uuid,
OrderByComparator<Role> orderByComparator)
Returns the last role in the ordered set where uuid = ?. |
static Role[] |
findByUuid_PrevAndNext(long roleId,
String uuid,
OrderByComparator<Role> orderByComparator)
Returns the roles before and after the current role in the ordered set where uuid = ?. |
static List<Role> |
findByUuid(String uuid)
Returns all the roles where uuid = ?. |
static List<Role> |
findByUuid(String uuid,
int start,
int end)
Returns a range of all the roles where uuid = ?. |
static List<Role> |
findByUuid(String uuid,
int start,
int end,
OrderByComparator<Role> orderByComparator)
Returns an ordered range of all the roles where uuid = ?. |
static List<Role> |
findByUuid(String uuid,
int start,
int end,
OrderByComparator<Role> orderByComparator,
boolean retrieveFromCache)
Returns an ordered range of all the roles where uuid = ?. |
static List<Role> |
findWithDynamicQuery(DynamicQuery dynamicQuery)
|
static List<Role> |
findWithDynamicQuery(DynamicQuery dynamicQuery,
int start,
int end)
|
static List<Role> |
findWithDynamicQuery(DynamicQuery dynamicQuery,
int start,
int end,
OrderByComparator<Role> orderByComparator)
|
static Set<String> |
getBadColumnNames()
|
static long[] |
getGroupPrimaryKeys(long pk)
Returns the primaryKeys of groups associated with the role. |
static List<Group> |
getGroups(long pk)
Returns all the groups associated with the role. |
static List<Group> |
getGroups(long pk,
int start,
int end)
Returns a range of all the groups associated with the role. |
static List<Group> |
getGroups(long pk,
int start,
int end,
OrderByComparator<Group> orderByComparator)
Returns an ordered range of all the groups associated with the role. |
static int |
getGroupsSize(long pk)
Returns the number of groups associated with the role. |
static RolePersistence |
getPersistence()
|
static long[] |
getUserPrimaryKeys(long pk)
Returns the primaryKeys of users associated with the role. |
static List<User> |
getUsers(long pk)
Returns all the users associated with the role. |
static List<User> |
getUsers(long pk,
int start,
int end)
Returns a range of all the users associated with the role. |
static List<User> |
getUsers(long pk,
int start,
int end,
OrderByComparator<User> orderByComparator)
Returns an ordered range of all the users associated with the role. |
static int |
getUsersSize(long pk)
Returns the number of users associated with the role. |
static Role |
remove(long roleId)
Removes the role with the primary key from the database. |
static void |
removeAll()
Removes all the roles from the database. |
static Role |
removeByC_C_C(long companyId,
long classNameId,
long classPK)
Removes the role where companyId = ? and classNameId = ? and classPK = ? from the database. |
static Role |
removeByC_N(long companyId,
String name)
Removes the role where companyId = ? and name = ? from the database. |
static void |
removeByC_T(long companyId,
int type)
Removes all the roles where companyId = ? and type = ? from the database. |
static void |
removeByCompanyId(long companyId)
Removes all the roles where companyId = ? from the database. |
static void |
removeByName(String name)
Removes all the roles where name = ? from the database. |
static void |
removeBySubtype(String subtype)
Removes all the roles where subtype = ? from the database. |
static void |
removeByT_S(int type,
String subtype)
Removes all the roles where type = ? and subtype = ? from the database. |
static void |
removeByType(int type)
Removes all the roles where type = ? from the database. |
static void |
removeByUuid_C(String uuid,
long companyId)
Removes all the roles where uuid = ? and companyId = ? from the database. |
static void |
removeByUuid(String uuid)
Removes all the roles where uuid = ? from the database. |
static void |
removeGroup(long pk,
Group group)
Removes the association between the role and the group. |
static void |
removeGroup(long pk,
long groupPK)
Removes the association between the role and the group. |
static void |
removeGroups(long pk,
List<Group> groups)
Removes the association between the role and the groups. |
static void |
removeGroups(long pk,
long[] groupPKs)
Removes the association between the role and the groups. |
static void |
removeUser(long pk,
long userPK)
Removes the association between the role and the user. |
static void |
removeUser(long pk,
User user)
Removes the association between the role and the user. |
static void |
removeUsers(long pk,
List<User> users)
Removes the association between the role and the users. |
static void |
removeUsers(long pk,
long[] userPKs)
Removes the association between the role and the users. |
static void |
setGroups(long pk,
List<Group> groups)
Sets the groups associated with the role, removing and adding associations as necessary. |
static void |
setGroups(long pk,
long[] groupPKs)
Sets the groups associated with the role, removing and adding associations as necessary. |
static void |
setUsers(long pk,
List<User> users)
Sets the users associated with the role, removing and adding associations as necessary. |
static void |
setUsers(long pk,
long[] userPKs)
Sets the users associated with the role, removing and adding associations as necessary. |
static Role |
update(Role role)
|
static Role |
update(Role role,
ServiceContext serviceContext)
|
static Role |
updateImpl(Role role)
|
| Methods inherited from class java.lang.Object |
|---|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait |
| Constructor Detail |
|---|
public RoleUtil()
| Method Detail |
|---|
public static void clearCache()
BasePersistence.clearCache()public static void clearCache(Role role)
BasePersistence.clearCache(com.liferay.portal.model.BaseModel)public static long countWithDynamicQuery(DynamicQuery dynamicQuery)
BasePersistence.countWithDynamicQuery(DynamicQuery)public static List<Role> findWithDynamicQuery(DynamicQuery dynamicQuery)
BasePersistence.findWithDynamicQuery(DynamicQuery)
public static List<Role> findWithDynamicQuery(DynamicQuery dynamicQuery,
int start,
int end)
BasePersistence.findWithDynamicQuery(DynamicQuery, int, int)
public static List<Role> findWithDynamicQuery(DynamicQuery dynamicQuery,
int start,
int end,
OrderByComparator<Role> orderByComparator)
BasePersistence.findWithDynamicQuery(DynamicQuery, int, int, OrderByComparator)public static Role update(Role role)
BasePersistence.update(com.liferay.portal.model.BaseModel)
public static Role update(Role role,
ServiceContext serviceContext)
BasePersistence.update(com.liferay.portal.model.BaseModel, ServiceContext)public static List<Role> findByUuid(String uuid)
uuid - the uuid
public static List<Role> 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 RoleModelImpl. 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 rolesend - the upper bound of the range of roles (not inclusive)
public static List<Role> findByUuid(String uuid,
int start,
int end,
OrderByComparator<Role> 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 RoleModelImpl. 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 rolesend - the upper bound of the range of roles (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static List<Role> findByUuid(String uuid,
int start,
int end,
OrderByComparator<Role> 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 RoleModelImpl. 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 rolesend - the upper bound of the range of roles (not inclusive)orderByComparator - the comparator to order the results by (optionally null)retrieveFromCache - whether to retrieve from the finder cache
public static Role findByUuid_First(String uuid,
OrderByComparator<Role> orderByComparator)
throws NoSuchRoleException
uuid - the uuidorderByComparator - the comparator to order the set by (optionally null)
NoSuchRoleException - if a matching role could not be found
public static Role fetchByUuid_First(String uuid,
OrderByComparator<Role> orderByComparator)
uuid - the uuidorderByComparator - the comparator to order the set by (optionally null)
null if a matching role could not be found
public static Role findByUuid_Last(String uuid,
OrderByComparator<Role> orderByComparator)
throws NoSuchRoleException
uuid - the uuidorderByComparator - the comparator to order the set by (optionally null)
NoSuchRoleException - if a matching role could not be found
public static Role fetchByUuid_Last(String uuid,
OrderByComparator<Role> orderByComparator)
uuid - the uuidorderByComparator - the comparator to order the set by (optionally null)
null if a matching role could not be found
public static Role[] findByUuid_PrevAndNext(long roleId,
String uuid,
OrderByComparator<Role> orderByComparator)
throws NoSuchRoleException
roleId - the primary key of the current roleuuid - the uuidorderByComparator - the comparator to order the set by (optionally null)
NoSuchRoleException - if a role with the primary key could not be foundpublic static List<Role> filterFindByUuid(String uuid)
uuid - the uuid
public static List<Role> filterFindByUuid(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 RoleModelImpl. 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 rolesend - the upper bound of the range of roles (not inclusive)
public static List<Role> filterFindByUuid(String uuid,
int start,
int end,
OrderByComparator<Role> 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 RoleModelImpl. 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 rolesend - the upper bound of the range of roles (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static Role[] filterFindByUuid_PrevAndNext(long roleId,
String uuid,
OrderByComparator<Role> orderByComparator)
throws NoSuchRoleException
roleId - the primary key of the current roleuuid - the uuidorderByComparator - the comparator to order the set by (optionally null)
NoSuchRoleException - if a role 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 int filterCountByUuid(String uuid)
uuid - the uuid
public static List<Role> findByUuid_C(String uuid,
long companyId)
uuid - the uuidcompanyId - the company ID
public static List<Role> 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 RoleModelImpl. 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 rolesend - the upper bound of the range of roles (not inclusive)
public static List<Role> findByUuid_C(String uuid,
long companyId,
int start,
int end,
OrderByComparator<Role> 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 RoleModelImpl. 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 rolesend - the upper bound of the range of roles (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static List<Role> findByUuid_C(String uuid,
long companyId,
int start,
int end,
OrderByComparator<Role> 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 RoleModelImpl. 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 rolesend - the upper bound of the range of roles (not inclusive)orderByComparator - the comparator to order the results by (optionally null)retrieveFromCache - whether to retrieve from the finder cache
public static Role findByUuid_C_First(String uuid,
long companyId,
OrderByComparator<Role> orderByComparator)
throws NoSuchRoleException
uuid - the uuidcompanyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchRoleException - if a matching role could not be found
public static Role fetchByUuid_C_First(String uuid,
long companyId,
OrderByComparator<Role> orderByComparator)
uuid - the uuidcompanyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
null if a matching role could not be found
public static Role findByUuid_C_Last(String uuid,
long companyId,
OrderByComparator<Role> orderByComparator)
throws NoSuchRoleException
uuid - the uuidcompanyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchRoleException - if a matching role could not be found
public static Role fetchByUuid_C_Last(String uuid,
long companyId,
OrderByComparator<Role> orderByComparator)
uuid - the uuidcompanyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
null if a matching role could not be found
public static Role[] findByUuid_C_PrevAndNext(long roleId,
String uuid,
long companyId,
OrderByComparator<Role> orderByComparator)
throws NoSuchRoleException
roleId - the primary key of the current roleuuid - the uuidcompanyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchRoleException - if a role with the primary key could not be found
public static List<Role> filterFindByUuid_C(String uuid,
long companyId)
uuid - the uuidcompanyId - the company ID
public static List<Role> filterFindByUuid_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 RoleModelImpl. 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 rolesend - the upper bound of the range of roles (not inclusive)
public static List<Role> filterFindByUuid_C(String uuid,
long companyId,
int start,
int end,
OrderByComparator<Role> 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 RoleModelImpl. 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 rolesend - the upper bound of the range of roles (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static Role[] filterFindByUuid_C_PrevAndNext(long roleId,
String uuid,
long companyId,
OrderByComparator<Role> orderByComparator)
throws NoSuchRoleException
roleId - the primary key of the current roleuuid - the uuidcompanyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchRoleException - if a role 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 int filterCountByUuid_C(String uuid,
long companyId)
uuid - the uuidcompanyId - the company ID
public static List<Role> findByCompanyId(long companyId)
companyId - the company ID
public static List<Role> findByCompanyId(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 RoleModelImpl. 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.
companyId - the company IDstart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)
public static List<Role> findByCompanyId(long companyId,
int start,
int end,
OrderByComparator<Role> 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 RoleModelImpl. 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.
companyId - the company IDstart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static List<Role> findByCompanyId(long companyId,
int start,
int end,
OrderByComparator<Role> 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 RoleModelImpl. 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.
companyId - the company IDstart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)orderByComparator - the comparator to order the results by (optionally null)retrieveFromCache - whether to retrieve from the finder cache
public static Role findByCompanyId_First(long companyId,
OrderByComparator<Role> orderByComparator)
throws NoSuchRoleException
companyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchRoleException - if a matching role could not be found
public static Role fetchByCompanyId_First(long companyId,
OrderByComparator<Role> orderByComparator)
companyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
null if a matching role could not be found
public static Role findByCompanyId_Last(long companyId,
OrderByComparator<Role> orderByComparator)
throws NoSuchRoleException
companyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchRoleException - if a matching role could not be found
public static Role fetchByCompanyId_Last(long companyId,
OrderByComparator<Role> orderByComparator)
companyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
null if a matching role could not be found
public static Role[] findByCompanyId_PrevAndNext(long roleId,
long companyId,
OrderByComparator<Role> orderByComparator)
throws NoSuchRoleException
roleId - the primary key of the current rolecompanyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchRoleException - if a role with the primary key could not be foundpublic static List<Role> filterFindByCompanyId(long companyId)
companyId - the company ID
public static List<Role> filterFindByCompanyId(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 RoleModelImpl. 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.
companyId - the company IDstart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)
public static List<Role> filterFindByCompanyId(long companyId,
int start,
int end,
OrderByComparator<Role> 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 RoleModelImpl. 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.
companyId - the company IDstart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static Role[] filterFindByCompanyId_PrevAndNext(long roleId,
long companyId,
OrderByComparator<Role> orderByComparator)
throws NoSuchRoleException
roleId - the primary key of the current rolecompanyId - the company IDorderByComparator - the comparator to order the set by (optionally null)
NoSuchRoleException - if a role with the primary key could not be foundpublic static void removeByCompanyId(long companyId)
companyId - the company IDpublic static int countByCompanyId(long companyId)
companyId - the company ID
public static int filterCountByCompanyId(long companyId)
companyId - the company ID
public static List<Role> findByName(String name)
name - the name
public static List<Role> findByName(String name,
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 RoleModelImpl. 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.
name - the namestart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)
public static List<Role> findByName(String name,
int start,
int end,
OrderByComparator<Role> 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 RoleModelImpl. 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.
name - the namestart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static List<Role> findByName(String name,
int start,
int end,
OrderByComparator<Role> 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 RoleModelImpl. 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.
name - the namestart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)orderByComparator - the comparator to order the results by (optionally null)retrieveFromCache - whether to retrieve from the finder cache
public static Role findByName_First(String name,
OrderByComparator<Role> orderByComparator)
throws NoSuchRoleException
name - the nameorderByComparator - the comparator to order the set by (optionally null)
NoSuchRoleException - if a matching role could not be found
public static Role fetchByName_First(String name,
OrderByComparator<Role> orderByComparator)
name - the nameorderByComparator - the comparator to order the set by (optionally null)
null if a matching role could not be found
public static Role findByName_Last(String name,
OrderByComparator<Role> orderByComparator)
throws NoSuchRoleException
name - the nameorderByComparator - the comparator to order the set by (optionally null)
NoSuchRoleException - if a matching role could not be found
public static Role fetchByName_Last(String name,
OrderByComparator<Role> orderByComparator)
name - the nameorderByComparator - the comparator to order the set by (optionally null)
null if a matching role could not be found
public static Role[] findByName_PrevAndNext(long roleId,
String name,
OrderByComparator<Role> orderByComparator)
throws NoSuchRoleException
roleId - the primary key of the current rolename - the nameorderByComparator - the comparator to order the set by (optionally null)
NoSuchRoleException - if a role with the primary key could not be foundpublic static List<Role> filterFindByName(String name)
name - the name
public static List<Role> filterFindByName(String name,
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 RoleModelImpl. 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.
name - the namestart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)
public static List<Role> filterFindByName(String name,
int start,
int end,
OrderByComparator<Role> 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 RoleModelImpl. 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.
name - the namestart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static Role[] filterFindByName_PrevAndNext(long roleId,
String name,
OrderByComparator<Role> orderByComparator)
throws NoSuchRoleException
roleId - the primary key of the current rolename - the nameorderByComparator - the comparator to order the set by (optionally null)
NoSuchRoleException - if a role with the primary key could not be foundpublic static void removeByName(String name)
name - the namepublic static int countByName(String name)
name - the name
public static int filterCountByName(String name)
name - the name
public static List<Role> findByType(int type)
type - the type
public static List<Role> findByType(int type,
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 RoleModelImpl. 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.
type - the typestart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)
public static List<Role> findByType(int type,
int start,
int end,
OrderByComparator<Role> 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 RoleModelImpl. 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.
type - the typestart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static List<Role> findByType(int type,
int start,
int end,
OrderByComparator<Role> 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 RoleModelImpl. 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.
type - the typestart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)orderByComparator - the comparator to order the results by (optionally null)retrieveFromCache - whether to retrieve from the finder cache
public static Role findByType_First(int type,
OrderByComparator<Role> orderByComparator)
throws NoSuchRoleException
type - the typeorderByComparator - the comparator to order the set by (optionally null)
NoSuchRoleException - if a matching role could not be found
public static Role fetchByType_First(int type,
OrderByComparator<Role> orderByComparator)
type - the typeorderByComparator - the comparator to order the set by (optionally null)
null if a matching role could not be found
public static Role findByType_Last(int type,
OrderByComparator<Role> orderByComparator)
throws NoSuchRoleException
type - the typeorderByComparator - the comparator to order the set by (optionally null)
NoSuchRoleException - if a matching role could not be found
public static Role fetchByType_Last(int type,
OrderByComparator<Role> orderByComparator)
type - the typeorderByComparator - the comparator to order the set by (optionally null)
null if a matching role could not be found
public static Role[] findByType_PrevAndNext(long roleId,
int type,
OrderByComparator<Role> orderByComparator)
throws NoSuchRoleException
roleId - the primary key of the current roletype - the typeorderByComparator - the comparator to order the set by (optionally null)
NoSuchRoleException - if a role with the primary key could not be foundpublic static List<Role> filterFindByType(int type)
type - the type
public static List<Role> filterFindByType(int type,
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 RoleModelImpl. 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.
type - the typestart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)
public static List<Role> filterFindByType(int type,
int start,
int end,
OrderByComparator<Role> 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 RoleModelImpl. 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.
type - the typestart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static Role[] filterFindByType_PrevAndNext(long roleId,
int type,
OrderByComparator<Role> orderByComparator)
throws NoSuchRoleException
roleId - the primary key of the current roletype - the typeorderByComparator - the comparator to order the set by (optionally null)
NoSuchRoleException - if a role with the primary key could not be foundpublic static void removeByType(int type)
type - the typepublic static int countByType(int type)
type - the type
public static int filterCountByType(int type)
type - the type
public static List<Role> findBySubtype(String subtype)
subtype - the subtype
public static List<Role> findBySubtype(String subtype,
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 RoleModelImpl. 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.
subtype - the subtypestart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)
public static List<Role> findBySubtype(String subtype,
int start,
int end,
OrderByComparator<Role> 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 RoleModelImpl. 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.
subtype - the subtypestart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static List<Role> findBySubtype(String subtype,
int start,
int end,
OrderByComparator<Role> 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 RoleModelImpl. 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.
subtype - the subtypestart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)orderByComparator - the comparator to order the results by (optionally null)retrieveFromCache - whether to retrieve from the finder cache
public static Role findBySubtype_First(String subtype,
OrderByComparator<Role> orderByComparator)
throws NoSuchRoleException
subtype - the subtypeorderByComparator - the comparator to order the set by (optionally null)
NoSuchRoleException - if a matching role could not be found
public static Role fetchBySubtype_First(String subtype,
OrderByComparator<Role> orderByComparator)
subtype - the subtypeorderByComparator - the comparator to order the set by (optionally null)
null if a matching role could not be found
public static Role findBySubtype_Last(String subtype,
OrderByComparator<Role> orderByComparator)
throws NoSuchRoleException
subtype - the subtypeorderByComparator - the comparator to order the set by (optionally null)
NoSuchRoleException - if a matching role could not be found
public static Role fetchBySubtype_Last(String subtype,
OrderByComparator<Role> orderByComparator)
subtype - the subtypeorderByComparator - the comparator to order the set by (optionally null)
null if a matching role could not be found
public static Role[] findBySubtype_PrevAndNext(long roleId,
String subtype,
OrderByComparator<Role> orderByComparator)
throws NoSuchRoleException
roleId - the primary key of the current rolesubtype - the subtypeorderByComparator - the comparator to order the set by (optionally null)
NoSuchRoleException - if a role with the primary key could not be foundpublic static List<Role> filterFindBySubtype(String subtype)
subtype - the subtype
public static List<Role> filterFindBySubtype(String subtype,
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 RoleModelImpl. 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.
subtype - the subtypestart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)
public static List<Role> filterFindBySubtype(String subtype,
int start,
int end,
OrderByComparator<Role> 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 RoleModelImpl. 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.
subtype - the subtypestart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static Role[] filterFindBySubtype_PrevAndNext(long roleId,
String subtype,
OrderByComparator<Role> orderByComparator)
throws NoSuchRoleException
roleId - the primary key of the current rolesubtype - the subtypeorderByComparator - the comparator to order the set by (optionally null)
NoSuchRoleException - if a role with the primary key could not be foundpublic static void removeBySubtype(String subtype)
subtype - the subtypepublic static int countBySubtype(String subtype)
subtype - the subtype
public static int filterCountBySubtype(String subtype)
subtype - the subtype
public static Role findByC_N(long companyId,
String name)
throws NoSuchRoleException
NoSuchRoleException if it could not be found.
companyId - the company IDname - the name
NoSuchRoleException - if a matching role could not be found
public static Role fetchByC_N(long companyId,
String name)
null if it could not be found. Uses the finder cache.
companyId - the company IDname - the name
null if a matching role could not be found
public static Role fetchByC_N(long companyId,
String name,
boolean retrieveFromCache)
null if it could not be found, optionally using the finder cache.
companyId - the company IDname - the nameretrieveFromCache - whether to retrieve from the finder cache
null if a matching role could not be found
public static Role removeByC_N(long companyId,
String name)
throws NoSuchRoleException
companyId - the company IDname - the name
NoSuchRoleException
public static int countByC_N(long companyId,
String name)
companyId - the company IDname - the name
public static List<Role> findByC_T(long companyId,
int type)
companyId - the company IDtype - the type
public static List<Role> findByC_T(long companyId,
int type,
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 RoleModelImpl. 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.
companyId - the company IDtype - the typestart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)
public static List<Role> findByC_T(long companyId,
int type,
int start,
int end,
OrderByComparator<Role> 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 RoleModelImpl. 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.
companyId - the company IDtype - the typestart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static List<Role> findByC_T(long companyId,
int type,
int start,
int end,
OrderByComparator<Role> 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 RoleModelImpl. 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.
companyId - the company IDtype - the typestart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)orderByComparator - the comparator to order the results by (optionally null)retrieveFromCache - whether to retrieve from the finder cache
public static Role findByC_T_First(long companyId,
int type,
OrderByComparator<Role> orderByComparator)
throws NoSuchRoleException
companyId - the company IDtype - the typeorderByComparator - the comparator to order the set by (optionally null)
NoSuchRoleException - if a matching role could not be found
public static Role fetchByC_T_First(long companyId,
int type,
OrderByComparator<Role> orderByComparator)
companyId - the company IDtype - the typeorderByComparator - the comparator to order the set by (optionally null)
null if a matching role could not be found
public static Role findByC_T_Last(long companyId,
int type,
OrderByComparator<Role> orderByComparator)
throws NoSuchRoleException
companyId - the company IDtype - the typeorderByComparator - the comparator to order the set by (optionally null)
NoSuchRoleException - if a matching role could not be found
public static Role fetchByC_T_Last(long companyId,
int type,
OrderByComparator<Role> orderByComparator)
companyId - the company IDtype - the typeorderByComparator - the comparator to order the set by (optionally null)
null if a matching role could not be found
public static Role[] findByC_T_PrevAndNext(long roleId,
long companyId,
int type,
OrderByComparator<Role> orderByComparator)
throws NoSuchRoleException
roleId - the primary key of the current rolecompanyId - the company IDtype - the typeorderByComparator - the comparator to order the set by (optionally null)
NoSuchRoleException - if a role with the primary key could not be found
public static List<Role> filterFindByC_T(long companyId,
int type)
companyId - the company IDtype - the type
public static List<Role> filterFindByC_T(long companyId,
int type,
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 RoleModelImpl. 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.
companyId - the company IDtype - the typestart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)
public static List<Role> filterFindByC_T(long companyId,
int type,
int start,
int end,
OrderByComparator<Role> 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 RoleModelImpl. 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.
companyId - the company IDtype - the typestart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static Role[] filterFindByC_T_PrevAndNext(long roleId,
long companyId,
int type,
OrderByComparator<Role> orderByComparator)
throws NoSuchRoleException
roleId - the primary key of the current rolecompanyId - the company IDtype - the typeorderByComparator - the comparator to order the set by (optionally null)
NoSuchRoleException - if a role with the primary key could not be found
public static List<Role> filterFindByC_T(long companyId,
int[] types)
companyId - the company IDtypes - the types
public static List<Role> filterFindByC_T(long companyId,
int[] types,
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 RoleModelImpl. 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.
companyId - the company IDtypes - the typesstart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)
public static List<Role> filterFindByC_T(long companyId,
int[] types,
int start,
int end,
OrderByComparator<Role> 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 RoleModelImpl. 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.
companyId - the company IDtypes - the typesstart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static List<Role> findByC_T(long companyId,
int[] types)
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 RoleModelImpl. 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.
companyId - the company IDtypes - the types
public static List<Role> findByC_T(long companyId,
int[] types,
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 RoleModelImpl. 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.
companyId - the company IDtypes - the typesstart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)
public static List<Role> findByC_T(long companyId,
int[] types,
int start,
int end,
OrderByComparator<Role> 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 RoleModelImpl. 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.
companyId - the company IDtypes - the typesstart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static List<Role> findByC_T(long companyId,
int[] types,
int start,
int end,
OrderByComparator<Role> 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 RoleModelImpl. 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.
companyId - the company IDtype - the typestart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)orderByComparator - the comparator to order the results by (optionally null)retrieveFromCache - whether to retrieve from the finder cache
public static void removeByC_T(long companyId,
int type)
companyId - the company IDtype - the type
public static int countByC_T(long companyId,
int type)
companyId - the company IDtype - the type
public static int countByC_T(long companyId,
int[] types)
companyId - the company IDtypes - the types
public static int filterCountByC_T(long companyId,
int type)
companyId - the company IDtype - the type
public static int filterCountByC_T(long companyId,
int[] types)
companyId - the company IDtypes - the types
public static List<Role> findByT_S(int type,
String subtype)
type - the typesubtype - the subtype
public static List<Role> findByT_S(int type,
String subtype,
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 RoleModelImpl. 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.
type - the typesubtype - the subtypestart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)
public static List<Role> findByT_S(int type,
String subtype,
int start,
int end,
OrderByComparator<Role> 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 RoleModelImpl. 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.
type - the typesubtype - the subtypestart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static List<Role> findByT_S(int type,
String subtype,
int start,
int end,
OrderByComparator<Role> 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 RoleModelImpl. 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.
type - the typesubtype - the subtypestart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)orderByComparator - the comparator to order the results by (optionally null)retrieveFromCache - whether to retrieve from the finder cache
public static Role findByT_S_First(int type,
String subtype,
OrderByComparator<Role> orderByComparator)
throws NoSuchRoleException
type - the typesubtype - the subtypeorderByComparator - the comparator to order the set by (optionally null)
NoSuchRoleException - if a matching role could not be found
public static Role fetchByT_S_First(int type,
String subtype,
OrderByComparator<Role> orderByComparator)
type - the typesubtype - the subtypeorderByComparator - the comparator to order the set by (optionally null)
null if a matching role could not be found
public static Role findByT_S_Last(int type,
String subtype,
OrderByComparator<Role> orderByComparator)
throws NoSuchRoleException
type - the typesubtype - the subtypeorderByComparator - the comparator to order the set by (optionally null)
NoSuchRoleException - if a matching role could not be found
public static Role fetchByT_S_Last(int type,
String subtype,
OrderByComparator<Role> orderByComparator)
type - the typesubtype - the subtypeorderByComparator - the comparator to order the set by (optionally null)
null if a matching role could not be found
public static Role[] findByT_S_PrevAndNext(long roleId,
int type,
String subtype,
OrderByComparator<Role> orderByComparator)
throws NoSuchRoleException
roleId - the primary key of the current roletype - the typesubtype - the subtypeorderByComparator - the comparator to order the set by (optionally null)
NoSuchRoleException - if a role with the primary key could not be found
public static List<Role> filterFindByT_S(int type,
String subtype)
type - the typesubtype - the subtype
public static List<Role> filterFindByT_S(int type,
String subtype,
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 RoleModelImpl. 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.
type - the typesubtype - the subtypestart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)
public static List<Role> filterFindByT_S(int type,
String subtype,
int start,
int end,
OrderByComparator<Role> 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 RoleModelImpl. 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.
type - the typesubtype - the subtypestart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static Role[] filterFindByT_S_PrevAndNext(long roleId,
int type,
String subtype,
OrderByComparator<Role> orderByComparator)
throws NoSuchRoleException
roleId - the primary key of the current roletype - the typesubtype - the subtypeorderByComparator - the comparator to order the set by (optionally null)
NoSuchRoleException - if a role with the primary key could not be found
public static void removeByT_S(int type,
String subtype)
type - the typesubtype - the subtype
public static int countByT_S(int type,
String subtype)
type - the typesubtype - the subtype
public static int filterCountByT_S(int type,
String subtype)
type - the typesubtype - the subtype
public static Role findByC_C_C(long companyId,
long classNameId,
long classPK)
throws NoSuchRoleException
NoSuchRoleException if it could not be found.
companyId - the company IDclassNameId - the class name IDclassPK - the class p k
NoSuchRoleException - if a matching role could not be found
public static Role fetchByC_C_C(long companyId,
long classNameId,
long classPK)
null if it could not be found. Uses the finder cache.
companyId - the company IDclassNameId - the class name IDclassPK - the class p k
null if a matching role could not be found
public static Role fetchByC_C_C(long companyId,
long classNameId,
long classPK,
boolean retrieveFromCache)
null if it could not be found, optionally using the finder cache.
companyId - the company IDclassNameId - the class name IDclassPK - the class p kretrieveFromCache - whether to retrieve from the finder cache
null if a matching role could not be found
public static Role removeByC_C_C(long companyId,
long classNameId,
long classPK)
throws NoSuchRoleException
companyId - the company IDclassNameId - the class name IDclassPK - the class p k
NoSuchRoleException
public static int countByC_C_C(long companyId,
long classNameId,
long classPK)
companyId - the company IDclassNameId - the class name IDclassPK - the class p k
public static void cacheResult(Role role)
role - the rolepublic static void cacheResult(List<Role> roles)
roles - the rolespublic static Role create(long roleId)
roleId - the primary key for the new role
public static Role remove(long roleId)
throws NoSuchRoleException
roleId - the primary key of the role
NoSuchRoleException - if a role with the primary key could not be foundpublic static Role updateImpl(Role role)
public static Role findByPrimaryKey(long roleId)
throws NoSuchRoleException
NoSuchRoleException if it could not be found.
roleId - the primary key of the role
NoSuchRoleException - if a role with the primary key could not be foundpublic static Role fetchByPrimaryKey(long roleId)
null if it could not be found.
roleId - the primary key of the role
null if a role with the primary key could not be foundpublic static Map<Serializable,Role> fetchByPrimaryKeys(Set<Serializable> primaryKeys)
public static List<Role> findAll()
public static List<Role> 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 RoleModelImpl. 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 rolesend - the upper bound of the range of roles (not inclusive)
public static List<Role> findAll(int start,
int end,
OrderByComparator<Role> 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 RoleModelImpl. 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 rolesend - the upper bound of the range of roles (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static List<Role> findAll(int start,
int end,
OrderByComparator<Role> 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 RoleModelImpl. 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 rolesend - the upper bound of the range of roles (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[] getGroupPrimaryKeys(long pk)
pk - the primary key of the role
public static List<Group> getGroups(long pk)
pk - the primary key of the role
public static List<Group> getGroups(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 RoleModelImpl. 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 rolestart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)
public static List<Group> getGroups(long pk,
int start,
int end,
OrderByComparator<Group> 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 RoleModelImpl. 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 rolestart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static int getGroupsSize(long pk)
pk - the primary key of the role
public static boolean containsGroup(long pk,
long groupPK)
true if the group is associated with the role.
pk - the primary key of the rolegroupPK - the primary key of the group
true if the group is associated with the role; false otherwisepublic static boolean containsGroups(long pk)
true if the role has any groups associated with it.
pk - the primary key of the role to check for associations with groups
true if the role has any groups associated with it; false otherwise
public static void addGroup(long pk,
long groupPK)
pk - the primary key of the rolegroupPK - the primary key of the group
public static void addGroup(long pk,
Group group)
pk - the primary key of the rolegroup - the group
public static void addGroups(long pk,
long[] groupPKs)
pk - the primary key of the rolegroupPKs - the primary keys of the groups
public static void addGroups(long pk,
List<Group> groups)
pk - the primary key of the rolegroups - the groupspublic static void clearGroups(long pk)
pk - the primary key of the role to clear the associated groups from
public static void removeGroup(long pk,
long groupPK)
pk - the primary key of the rolegroupPK - the primary key of the group
public static void removeGroup(long pk,
Group group)
pk - the primary key of the rolegroup - the group
public static void removeGroups(long pk,
long[] groupPKs)
pk - the primary key of the rolegroupPKs - the primary keys of the groups
public static void removeGroups(long pk,
List<Group> groups)
pk - the primary key of the rolegroups - the groups
public static void setGroups(long pk,
long[] groupPKs)
pk - the primary key of the rolegroupPKs - the primary keys of the groups to be associated with the role
public static void setGroups(long pk,
List<Group> groups)
pk - the primary key of the rolegroups - the groups to be associated with the rolepublic static long[] getUserPrimaryKeys(long pk)
pk - the primary key of the role
public static List<User> getUsers(long pk)
pk - the primary key of the role
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 RoleModelImpl. 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 rolestart - the lower bound of the range of rolesend - the upper bound of the range of roles (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 RoleModelImpl. 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 rolestart - the lower bound of the range of rolesend - the upper bound of the range of roles (not inclusive)orderByComparator - the comparator to order the results by (optionally null)
public static int getUsersSize(long pk)
pk - the primary key of the role
public static boolean containsUser(long pk,
long userPK)
true if the user is associated with the role.
pk - the primary key of the roleuserPK - the primary key of the user
true if the user is associated with the role; false otherwisepublic static boolean containsUsers(long pk)
true if the role has any users associated with it.
pk - the primary key of the role to check for associations with users
true if the role has any users associated with it; false otherwise
public static void addUser(long pk,
long userPK)
pk - the primary key of the roleuserPK - the primary key of the user
public static void addUser(long pk,
User user)
pk - the primary key of the roleuser - the user
public static void addUsers(long pk,
long[] userPKs)
pk - the primary key of the roleuserPKs - the primary keys of the users
public static void addUsers(long pk,
List<User> users)
pk - the primary key of the roleusers - the userspublic static void clearUsers(long pk)
pk - the primary key of the role to clear the associated users from
public static void removeUser(long pk,
long userPK)
pk - the primary key of the roleuserPK - the primary key of the user
public static void removeUser(long pk,
User user)
pk - the primary key of the roleuser - the user
public static void removeUsers(long pk,
long[] userPKs)
pk - the primary key of the roleuserPKs - the primary keys of the users
public static void removeUsers(long pk,
List<User> users)
pk - the primary key of the roleusers - the users
public static void setUsers(long pk,
long[] userPKs)
pk - the primary key of the roleuserPKs - the primary keys of the users to be associated with the role
public static void setUsers(long pk,
List<User> users)
pk - the primary key of the roleusers - the users to be associated with the rolepublic static Set<String> getBadColumnNames()
public static RolePersistence getPersistence()
|
Liferay 7.0-ce-b4 | |||||||||
| PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
| SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD | |||||||||