Package edu.internet2.middleware.grouper

Class GroupFinder

java.lang.Object
edu.internet2.middleware.grouper.GroupFinder
public class GroupFinder extends Object

Use this class to find groups within the Groups registry

Sample call 

 Group group = GroupFinder.findByName(grouperSession, "test", true);

Sample call to find groups a subject has specific privileges on 

 Set groups = new GroupFinder().assignPrivileges(AccessPrivilege.VIEW_PRIVILEGES)
       .assignField(Group.getDefaultList()).assignSubject(subject)
       .assignQueryOptions(new QueryOptions().paging(1000, 1, false)).findGroups();

  • Constructor Details

    • GroupFinder

      public GroupFinder()
      default constructor

  • Method Details

    • groupCacheAsRootAddSystemGroup

      public static void groupCacheAsRootAddSystemGroup(Group group)

      Grouper internal method only

      Parameters:
      group -

    • groupCacheClear

      public static void groupCacheClear()

      Grouper internal method only

      remove all caches

    • groupCacheRemove

      public static void groupCacheRemove(Group group)

      Grouper internal method only

      remove this from all caches
      Parameters:
      group -

    • assignCompositeOwner

      public GroupFinder assignCompositeOwner(Boolean theCompositeOwner)
      if we are filtering for groups which are composite owners or not
      Parameters:
      theCompositeOwner -
      Returns:
      this for chaining

    • findByAttribute

      @Deprecated public static Group findByAttribute(GrouperSession s, String attr, String val) throws GroupNotFoundException, IllegalArgumentException
      Deprecated.
      use the overload
      Find Group by attribute value. 
       try {
   Group g = GroupFinder.findByAttribute(s, "description", "some value");
 }
 catch (GroupNotFoundException eGNF) {
 }
      Parameters:
      s - Search within this session context.
      attr - Search on this attribute.
      val - Search for this value.
      Returns:
      Matching Group.
      Throws:
      GroupNotFoundException
      IllegalArgumentException
      Since:
      1.1.0

    • findByAttribute

      public static Group findByAttribute(GrouperSession s, String attr, String val, boolean exceptionOnNull) throws GroupNotFoundException, IllegalArgumentException
      Find Group by attribute value. 
         Group g = GroupFinder.findByAttribute(s, "description", "some value", true);
      Parameters:
      s - Search within this session context.
      attr - Search on this attribute.
      val - Search for this value.
      exceptionOnNull - true if there should be an exception on null
      Returns:
      Matching Group.
      Throws:
      GroupNotFoundException
      IllegalArgumentException
      Since:
      1.1.0

    • findAllByAttribute

      public static Set<Group> findAllByAttribute(GrouperSession s, String attr, String val) throws IllegalArgumentException
      Find Groups by attribute value. Returns groups or empty set if none (never null) 
         Set groups = GroupFinder.findAllByAttribute(s, "description", "some value");
      Parameters:
      s - Search within this session context.
      attr - Search on this attribute.
      val - Search for this value.
      Returns:
      Matching Group.
      Throws:
      IllegalArgumentException
      Since:
      1.1.0

    • findByName

      @Deprecated public static Group findByName(GrouperSession s, String name) throws GroupNotFoundException
      Deprecated.
      Find a group within the registry by name. 
       try {
   Group g = GroupFinder.findByName(name);
 }
 catch (GroupNotFoundException e) {
   // Group not found
 }
      Parameters:
      s - Find group within this session context.
      name - Name of group to find.
      Returns:
      A Group
      Throws:
      GroupNotFoundException

    • findByName

      public static Group findByName(GrouperSession s, String name, boolean exceptionIfNotFound) throws GroupNotFoundException
      Find a group within the registry by name. 
       try {
   Group g = GroupFinder.findByName(name);
 }
 catch (GroupNotFoundException e) {
   // Group not found
 }
      Parameters:
      s - Find group within this session context.
      name - Name of group to find.
      exceptionIfNotFound -
      Returns:
      A Group
      Throws:
      GroupNotFoundException

    • findByNameAsGrouperSystem

      public static Group findByNameAsGrouperSystem(String name, boolean exceptionIfNotFound) throws GroupNotFoundException
      Find a group within the registry by name as grouper system. 
       try {
   Group g = GroupFinder.findByName(name);
 }
 catch (GroupNotFoundException e) {
   // Group not found
 }
      Parameters:
      s - Find group within this session context.
      name - Name of group to find.
      exceptionIfNotFound -
      Returns:
      A Group
      Throws:
      GroupNotFoundException

    • findByName

      public static Group findByName(String name, boolean exceptionIfNotFound)
      Find a group within the registry by name. 
       try {
   Group g = GroupFinder.findByName(name, true);
 }
 catch (GroupNotFoundException e) {
   // Group not found
 }
      Parameters:
      name - Name of group to find.
      exceptionIfNotFound -
      queryOptions - paging, sorting, caching options
      Returns:
      A Group
      Throws:
      GroupNotFoundException

    • findByName

      public static Group findByName(GrouperSession s, String name, boolean exceptionIfNotFound, QueryOptions queryOptions) throws GroupNotFoundException
      Find a group within the registry by name. 
       try {
   Group g = GroupFinder.findByName(name);
 }
 catch (GroupNotFoundException e) {
   // Group not found
 }
      Parameters:
      s - Find group within this session context.
      name - Name of group to find.
      exceptionIfNotFound -
      queryOptions - paging, sorting, caching options
      Returns:
      A Group
      Throws:
      GroupNotFoundException

    • findByApproximateDescriptionSecure

      public static Set<Group> findByApproximateDescriptionSecure(String description, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroups)

    • findByDescriptionSecure

      public static Set<Group> findByDescriptionSecure(String description, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroups)

    • findByDisplayNameSecure

      public static Set<Group> findByDisplayNameSecure(String displayName, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroups)

    • findByApproximateDisplayNameSecure

      public static Set<Group> findByApproximateDisplayNameSecure(String displayName, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroups)

    • findByExtensionSecure

      public static Set<Group> findByExtensionSecure(String extension, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroups)

    • findByApproximateExtensionSecure

      public static Set<Group> findByApproximateExtensionSecure(String extension, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroups)

    • findByDisplayExtensionSecure

      public static Set<Group> findByDisplayExtensionSecure(String displayExtension, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroups)

    • findByApproximateDisplayExtensionSecure

      public static Set<Group> findByApproximateDisplayExtensionSecure(String extension, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroups)

    • findByCurrentName

      public static Group findByCurrentName(GrouperSession s, String name, boolean exceptionIfNotFound) throws GroupNotFoundException
      Find a group within the registry by its current name. 
       try {
   Group g = GroupFinder.findByCurrentName(name, true);
 }
 catch (GroupNotFoundException e) {
   // Group not found
 }
      Parameters:
      s - Find group within this session context.
      name - Name of group to find.
      exceptionIfNotFound -
      Returns:
      A Group
      Throws:
      GroupNotFoundException

    • findByAlternateName

      public static Group findByAlternateName(GrouperSession s, String name, boolean exceptionIfNotFound) throws GroupNotFoundException
      Find a group within the registry by its alternate name. 
       try {
   Group g = GroupFinder.findByAlternateName(name, true);
 }
 catch (GroupNotFoundException e) {
   // Group not found
 }
      Parameters:
      s - Find group within this session context.
      name - Name of group to find.
      exceptionIfNotFound -
      Returns:
      A Group
      Throws:
      GroupNotFoundException

    • findAllByType

      public static Set<Group> findAllByType(GrouperSession s, GroupType type) throws IllegalArgumentException
      Find all groups within the registry by their GroupType. Or empty set if none (never null). 
         Set groups = GroupFinder.findAllByType( s, GroupTypeFinder.find("your type") );
      Parameters:
      s - Find group within this session context.
      type - Find group with this GroupType.
      Returns:
      A set of Groups
      Throws:
      IllegalArgumentException

    • findByUuid

      @Deprecated public static Group findByUuid(GrouperSession s, String uuid) throws GroupNotFoundException
      Deprecated.
      Find a group within the registry by UUID. 
         Group g = GroupFinder.findByUuid(s, uuid);
      Parameters:
      s - Find group within this session context.
      uuid - UUID of group to find.
      Returns:
      A Group
      Throws:
      GroupNotFoundException

    • findByUuid

      public static Group findByUuid(String uuid, boolean exceptionIfNotFound)
      Find a group within the registry by UUID. 
         Group g = GroupFinder.findByUuid(s, uuid);
      Parameters:
      s - Find group within this session context.
      uuid - UUID of group to find.
      exceptionIfNotFound - true if exception if not found
      Returns:
      A Group
      Throws:
      GroupNotFoundException - if not found an exceptionIfNotFound is true

    • findByUuidAsGrouperSystem

      public static Group findByUuidAsGrouperSystem(String uuid, boolean exceptionIfNotFound)
      Find a group within the registry by UUID as grouper system. 
         Group g = GroupFinder.findByUuid(s, uuid);
      Parameters:
      s - Find group within this session context.
      uuid - UUID of group to find.
      exceptionIfNotFound - true if exception if not found
      Returns:
      A Group
      Throws:
      GroupNotFoundException - if not found an exceptionIfNotFound is true

    • findByUuid

      public static Group findByUuid(GrouperSession s, String uuid, boolean exceptionIfNotFound) throws GroupNotFoundException
      Find a group within the registry by UUID. 
         Group g = GroupFinder.findByUuid(s, uuid);
      Parameters:
      s - Find group within this session context.
      uuid - UUID of group to find.
      exceptionIfNotFound - true if exception if not found
      Returns:
      A Group
      Throws:
      GroupNotFoundException - if not found an exceptionIfNotFound is true

    • findByUuid

      public static Group findByUuid(GrouperSession s, String uuid, boolean exceptionIfNotFound, QueryOptions queryOptions) throws GroupNotFoundException
      Find a group within the registry by UUID. 
         Group g = GroupFinder.findByUuid(s, uuid);
      Parameters:
      s - Find group within this session context.
      uuid - UUID of group to find.
      exceptionIfNotFound - true if exception if not found
      queryOptions -
      Returns:
      A Group
      Throws:
      GroupNotFoundException - if not found an exceptionIfNotFound is true

    • findByIdIndexSecure

      public static Group findByIdIndexSecure(Long idIndex, boolean exceptionIfNotFound, QueryOptions queryOptions) throws GroupNotFoundException
      Find a group within the registry by ID index.
      Parameters:
      idIndex - id index of group to find.
      exceptionIfNotFound - true if exception if not found
      queryOptions -
      Returns:
      A Group
      Throws:
      GroupNotFoundException - if not found an exceptionIfNotFound is true

    • assignSubjectNotInGroup

      public GroupFinder assignSubjectNotInGroup(Subject theSubjectNotInGroup)
      assign a subject which does not have an immediate membership in the group
      Parameters:
      theSubjectNotInGroup -
      Returns:
      this for chaining

    • addPrivilege

      public GroupFinder addPrivilege(Privilege privilege)
      add a privilege to filter by that the subject has on the group
      Parameters:
      privilege - should be AccessPrivilege
      Returns:
      this for chaining

    • assignPrivileges

      public GroupFinder assignPrivileges(Set<Privilege> theGroups)
      assign privileges to filter by that the subject has on the group
      Parameters:
      theGroups -
      Returns:
      this for chaining

    • assignQueryOptions

      public GroupFinder assignQueryOptions(QueryOptions theQueryOptions)
      if sorting, paging, caching, etc
      Parameters:
      theQueryOptions -
      Returns:
      this for chaining

    • assignAttributeCheckReadOnAttributeDef

      public GroupFinder assignAttributeCheckReadOnAttributeDef(boolean theAttributeDefNameUseSecurity)
      use security around attribute def? default is true
      Parameters:
      theAttributeDefNameUseSecurity -
      Returns:
      this for chaining

    • assignAttributeNotAssigned

      public GroupFinder assignAttributeNotAssigned(boolean attributeNotAssigned)
      find groups that don't have a certain type assigned
      Parameters:
      attributeNotAssigned -
      Returns:

    • assignAttributeValuesOnAssignment

      public GroupFinder assignAttributeValuesOnAssignment(Set<Object> theValues)
      if looking for an attribute value on an assignment, could be multiple values
      Parameters:
      theValues -
      Returns:
      this for chaining

    • addAttributeValuesOnAssignment

      public GroupFinder addAttributeValuesOnAssignment(Object value)
      if looking for an attribute value on an assignment, could be multiple values
      Parameters:
      theValues -
      Returns:
      this for chaining

    • assignAttributeValue

      public GroupFinder assignAttributeValue(Object theValue)
      find objects with this value
      Parameters:
      theValue -
      Returns:
      this for chaining

    • assignIdOfAttributeDefName

      public GroupFinder assignIdOfAttributeDefName(String theAttributeDefNameId)
      find groups that have this attribute def name id, note could be an assignment on an assignment
      Parameters:
      theAttributeDefNameId -
      Returns:
      this for chaining

    • assignNameOfAttributeDefName

      public GroupFinder assignNameOfAttributeDefName(String theNameOfAttributeDefName)
      find groups that have this attribute assigned
      Parameters:
      theNameOfAttributeDefName -
      Returns:
      this for chaining

    • addGroupId

      public GroupFinder addGroupId(String groupId)
      add a group id to search for
      Parameters:
      groupId -
      Returns:
      this for chaining

    • assignGroupNames

      public GroupFinder assignGroupNames(Collection<String> theGroupNames)
      assign group names to search for
      Parameters:
      theGroupNames -
      Returns:
      this for chaining

    • addGroupName

      public GroupFinder addGroupName(String groupName)
      add a group name to search for
      Parameters:
      groupName -
      Returns:
      this for chaining

    • assignGroupIds

      public GroupFinder assignGroupIds(Collection<String> theGroupIds)
      assign group ids to search for
      Parameters:
      theGroupIds -
      Returns:
      this for chaining

    • assignField

      public GroupFinder assignField(Field theField)
      field to look for if searching for memberships in groups
      Parameters:
      theField -
      Returns:
      this for chaining

    • assignFieldName

      public GroupFinder assignFieldName(String theFieldName)
      field name to look for if searching for memberships in groups
      Parameters:
      theFieldName -
      Returns:
      theFieldName

    • assignMembershipsForSubject

      public GroupFinder assignMembershipsForSubject(boolean membershipsForSubject1)
      if this is true, or there is a field assigned, then get memberships for a subject
      Parameters:
      membershipsForSubject1 -
      Returns:
      this for chaining

    • findGroups

      public Set<Group> findGroups()
      find all the group
      Returns:
      the set of groups or the empty set if none found

    • assignTypeOfGroups

      public GroupFinder assignTypeOfGroups(Set<TypeOfGroup> theTypeOfGroups)
      Parameters:
      theTypeOfGroups -
      Returns:
      this for chaining

    • addTypeOfGroup

      public GroupFinder addTypeOfGroup(TypeOfGroup typeOfGroup)
      Parameters:
      typeOfGroup -
      Returns:
      this

    • assignScope

      public GroupFinder assignScope(String theScope)
      scope to look for groups Wildcards will be appended or percent is the wildcard
      Parameters:
      theScope -
      Returns:
      this for chaining

    • assignSplitScope

      public GroupFinder assignSplitScope(boolean theSplitScope)
      if the scope has spaces in it, then split by whitespace, and find results that contain all of the scope strings
      Parameters:
      theSplitScope -
      Returns:
      this for chaining

    • assignSubject

      public GroupFinder assignSubject(Subject theSubject)
      this is the subject that has certain memberships in the query
      Parameters:
      theSubject -
      Returns:
      this for chaining

    • assignParentStemId

      public GroupFinder assignParentStemId(String theParentStemId)
      parent or ancestor stem of the group
      Parameters:
      theParentStemId -
      Returns:
      this for chaining

    • assignStemScope

      public GroupFinder assignStemScope(Stem.Scope theStemScope)
      if passing in a stem, this is the stem scope...
      Parameters:
      theStemScope -
      Returns:
      this for chaining

    • assignFindByUuidOrName

      public GroupFinder assignFindByUuidOrName(boolean theFindByUuidOrName)
      if we are looking up a group, only look by uuid or name
      Parameters:
      theFindByUuidOrName -
      Returns:
      the group finder

    • findGroup

      public Group findGroup()
      find the group
      Returns:
      the group or null

    • assignAttributeValue2

      public GroupFinder assignAttributeValue2(Object theValue)
      find objects with this value2
      Parameters:
      theValue -
      Returns:
      this for chaining

    • assignIdOfAttributeDefName2

      public GroupFinder assignIdOfAttributeDefName2(String theAttributeDefNameId)
      find groups that have this attribute def name id, note could be an assignment on an assignment
      Parameters:
      theAttributeDefNameId -
      Returns:
      this for chaining

    • assignNameOfAttributeDefName2

      public GroupFinder assignNameOfAttributeDefName2(String theNameOfAttributeDefName)
      find groups that have this attribute assigned
      Parameters:
      theNameOfAttributeDefName -
      Returns:
      this for chaining

    • addAttributeValuesOnAssignment2

      public GroupFinder addAttributeValuesOnAssignment2(Object value)
      if looking for an attribute value on an assignment2, could be multiple values
      Parameters:
      value -
      Returns:
      this for chaining

    • assignAttributeValuesOnAssignment2

      public GroupFinder assignAttributeValuesOnAssignment2(Set<Object> theValues)
      if looking for an attribute value on an assignment2, could be multiple values
      Parameters:
      theValues -
      Returns:
      this for chaining

    • assignExcludeAlternateNames

      public GroupFinder assignExcludeAlternateNames(boolean excludeAlternateNames)
      whether to exclude alternate names from name/scope search
      Parameters:
      excludeAlternateNames -
      Returns:

    • findInternalIdsByNames

      public static Map<String,Long> findInternalIdsByNames(Set<String> groupNames2)
      this will cache for a minute, find internal ids by name
      Parameters:
      groupNames2 -
      Returns:
      the internal ids