Hib3GroupDAO (Grouper API 2.5.0-SNAPSHOT Java API.)

java.lang.Object
- edu.internet2.middleware.grouper.internal.dao.hib3.Hib3DAO
- - edu.internet2.middleware.grouper.internal.dao.hib3.Hib3GroupDAO

All Implemented Interfaces:

GroupDAO, GrouperDAO
```
public class Hib3GroupDAO
extends Hib3DAO
implements GroupDAO
```
Basic Hibernate Group DAO interface.

Since:

@HEAD@

Version:

$Id: Hib3GroupDAO.java,v 1.51 2009-12-10 08:54:15 mchyzer Exp $

Constructor Summary

Constructors
Constructor and Description

Hib3GroupDAO()

Constructors
Constructor and Description
`Hib3GroupDAO()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`static String`	`assignFilterToQuery(String filter, Boolean splitScope, StringBuilder whereClause, ByHqlStatic byHqlStatic, boolean findByUuidOrName, String alias, boolean addFinalParen)`
`void`	`delete(Group _g)`
`boolean`	`exists(String uuid)`
`Set<Group>`	`findAllByAnyApproximateAttr(String val)`
`Set<Group>`	`findAllByAnyApproximateAttr(String val, String scope)`
`Set<Group>`	`findAllByAnyApproximateAttr(String val, String scope, boolean secureQuery)`
`Set<Group>`	`findAllByAnyApproximateAttr(String val, String scope, boolean secureQuery, Boolean enabled)`
`Set<Group>`	`findAllByApproximateAlternateName(String name)` Find groups using an approximate string for the alternate name.
`Set<Group>`	`findAllByApproximateAlternateName(String name, String scope)` Find groups using an approximate string for the alternate name.
`Set<Group>`	`findAllByApproximateAttr(String attr, String val)` Implementation Notes.
`Set<Group>`	`findAllByApproximateAttr(String attr, String val, String scope)` Implementation Notes.
`Set<Group>`	`findAllByApproximateAttrSecure(String attr, String val, String scope)`
`Set<Group>`	`findAllByApproximateAttrSecure(String attr, String val, String scope, Boolean enabled)`
`Set<Group>`	`findAllByApproximateCurrentName(String name)` Find groups using an approximate string for the current name, display name, extension, display extension.
`Set<Group>`	`findAllByApproximateCurrentName(String name, String scope)` Find groups using an approximate string for the current name, display name, extension, display extension.
`Set<Group>`	`findAllByApproximateName(String name)` Implementation Notes.
`Set<Group>`	`findAllByApproximateName(String name, String scope)` Implementation Notes.
`Set<Group>`	`findAllByApproximateNameSecure(String name, String scope, QueryOptions queryOptions)` Implementation Notes.
`Set<Group>`	`findAllByApproximateNameSecure(String name, String scope, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroups)` Implementation Notes.
`Set<Group>`	`findAllByApproximateNameSecure(String name, String scope, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroups, Boolean enabled)` Implementation Notes.
`Set<Group>`	`findAllByAttr(String attr, String val)` Implementation Notes.
`Set<Group>`	`findAllByAttr(String attr, String val, String scope)` Implementation Notes.
`Set<Group>`	`findAllByAttr(String attr, String val, String scope, boolean secureQuery)`
`Set<Group>`	`findAllByAttr(String attr, String val, String scope, boolean secureQuery, Boolean enabled)` (non-Javadoc)
`Set<Group>`	`findAllByCreatedAfter(Date d)`
`Set<Group>`	`findAllByCreatedAfter(Date d, String scope)`
`Set<Group>`	`findAllByCreatedBefore(Date d)`
`Set<Group>`	`findAllByCreatedBefore(Date d, String scope)`
`Set<Group>`	`findAllByLastMembershipAfter(Date d)`
`Set<Group>`	`findAllByLastMembershipAfter(Date d, String scope)`
`Set<Group>`	`findAllByLastMembershipBefore(Date d)`
`Set<Group>`	`findAllByLastMembershipBefore(Date d, String scope)`
`Set<Group>`	`findAllByModifiedAfter(Date d)`
`Set<Group>`	`findAllByModifiedAfter(Date d, String scope)`
`Set<Group>`	`findAllByModifiedBefore(Date d)`
`Set<Group>`	`findAllByModifiedBefore(Date d, String scope)`
`Set<Group>`	`findAllByType(GroupType _gt)` Note, this doesnt cache
`Set<Group>`	`findAllByType(GroupType _gt, QueryOptions queryOptions)` this caches
`Set<Group>`	`findAllByType(GroupType _gt, String scope)`
`Set<Group>`	`findAllEnabledDisabledMismatch()` find records which are disabled which shouldnt be, and enabled which shouldnt be
`Group`	`findByAlternateName(String name, boolean exceptionIfNotFound)` Find a group by its alternate name only.
`Set<Group>`	`findByApproximateDescriptionSecure(String description, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroups)`
`Set<Group>`	`findByApproximateDisplayExtensionSecure(String displayExtension, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroups)`
`Set<Group>`	`findByApproximateDisplayNameSecure(String displayName, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroups)`
`Set<Group>`	`findByApproximateExtensionSecure(String extension, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroups)`
`Group`	`findByAttribute(String attr, String val)` Deprecated. use overload
`Group`	`findByAttribute(String attr, String val, boolean exceptionIfNotFound)`
`Group`	`findByAttribute(String attr, String val, boolean exceptionIfNotFound, boolean secureQuery)`
`Set<Group>`	`findByCreatorOrModifier(Member member)` find groups by creator or modifier
`Group`	`findByCurrentName(String name, boolean exceptionIfNotFound)` Find a group by its current name only.
`Set<Group>`	`findByDescriptionSecure(String description, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroups)`
`Set<Group>`	`findByDisplayExtensionSecure(String displayExtension, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroups)`
`Set<Group>`	`findByDisplayNameSecure(String displayName, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroups)`
`Set<Group>`	`findByExtensionSecure(String extension, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroups)`
`Group`	`findByIdIndex(Long idIndex, boolean exceptionIfNotFound)` not a secure method, find by id index
`Group`	`findByIdIndexSecure(Long idIndex, boolean exceptionIfNotFound, QueryOptions queryOptions)` find a group by id index
`Group`	`findByName(String name)` Deprecated. use overload
`Group`	`findByName(String name, boolean exceptionIfNotFound)`
`Group`	`findByName(String name, boolean exceptionIfNotFound, QueryOptions queryOptions)`
`Group`	`findByName(String name, boolean exceptionIfNotFound, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroups)`
`Group`	`findByNameSecure(String name, boolean exceptionIfNotFound, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroups)`
`Group`	`findByNameSecure(String name, boolean exceptionIfNotFound, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroups, Set<Privilege> inPrivSet)`
`Set<Group>`	`findByNamesSecure(Collection<String> names, QueryOptions queryOptions)`
`Set<Group>`	`findByNamesSecure(Collection<String> names, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroups)`
`Group`	`findByUuid(String uuid)` Deprecated. use overload
`Group`	`findByUuid(String uuid, boolean exceptionIfNotFound)`
`Group`	`findByUuid(String uuid, boolean exceptionIfNotFound, QueryOptions queryOptions)`
`Group`	`findByUuid(String uuid, boolean exceptionIfNotFound, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroups)`
`Group`	`findByUuidOrName(String uuid, String name, boolean exceptionIfNull)`
`Group`	`findByUuidOrName(String uuid, String name, boolean exceptionIfNull, QueryOptions queryOptions)`
`Set<Group>`	`findByUuids(Collection<String> uuids, boolean exceptionOnNotFound)` find all groups which have these uuids
`Group`	`findByUuidSecure(String uuid, boolean exceptionIfNotFound, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroups)` find by uuid secure
`Set<Group>`	`findByUuidsSecure(Collection<String> uuids, QueryOptions queryOptions)` find by uuid secure
`Set<Group>`	`findByUuidsSecure(Collection<String> uuids, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroups)` find by uuid secure
`Set<Group>`	`findGroupsInStemWithoutPrivilege(GrouperSession grouperSession, String stemId, Stem.Scope scope, Subject subject, Privilege privilege, QueryOptions queryOptions, boolean considerAllSubject, String sqlLikeString)` see which groups do not have this privilege
`Set<Group>`	`findGroupsInStemWithPrivilege(GrouperSession grouperSession, String stemId, Stem.Scope scope, Subject subject, Privilege privilege, QueryOptions queryOptions, boolean considerAllSubject, String sqlLikeString)` see which groups do not have this privilege
`Set<Group>`	`getAllGroups()`
`Set<Group>`	`getAllGroups(String scope)`
`Set<Group>`	`getAllGroupsMembershipSecure(Field field, String scope, GrouperSession grouperSession, Subject subject, QueryOptions queryOptions, Boolean enabled, MembershipType membershipType, Stem stem, Stem.Scope stemScope)`
`Set<Group>`	`getAllGroupsMembershipSecure(GrouperSession grouperSession, Subject subject, Set<Privilege> inPrivSet, QueryOptions queryOptions, boolean enabledOnly)`
`Set<Group>`	`getAllGroupsMembershipSecure(String scope, GrouperSession grouperSession, Subject subject, Set<Privilege> inPrivSet, QueryOptions queryOptions, boolean enabledOnly)`
`Set<Group>`	`getAllGroupsMembershipSecure(String scope, GrouperSession grouperSession, Subject subject, Set<Privilege> inPrivSet, QueryOptions queryOptions, boolean enabledOnly, Stem stem, Stem.Scope stemScope)`
`Set<Group>`	`getAllGroupsSecure(GrouperSession grouperSession, Subject subject, Set<Privilege> inPrivSet, QueryOptions queryOptions)`
`Set<Group>`	`getAllGroupsSecure(GrouperSession grouperSession, Subject subject, Set<Privilege> inPrivSet, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroups)` In this case, send in the attribute name to sort by (default is displayName).
`Set<Group>`	`getAllGroupsSecure(GrouperSession grouperSession, Subject subject, Set<Privilege> inPrivSet, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroups, Boolean enabled)` In this case, send in the attribute name to sort by (default is displayName).
`Set<Group>`	`getAllGroupsSecure(String scope, GrouperSession grouperSession, Subject subject, Set<Privilege> inPrivSet, QueryOptions queryOptions)`
`Set<Group>`	`getAllGroupsSecure(String scope, GrouperSession grouperSession, Subject subject, Set<Privilege> inPrivSet, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroups)`
`Set<Group>`	`getAllGroupsSecure(String scope, GrouperSession grouperSession, Subject subject, Set<Privilege> inPrivSet, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroups, Boolean enabled)`
`Set<Group>`	`getAllGroupsSecure(String scope, GrouperSession grouperSession, Subject subject, Set<Privilege> privileges, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroups, boolean splitScope, Subject membershipSubject, Field field)` get all groups secure, split the scope by whitespace
`Set<Group>`	`getAllGroupsSecure(String scope, GrouperSession grouperSession, Subject subject, Set<Privilege> privileges, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroups, boolean splitScope, Subject membershipSubject, Field field, String parentStemId, Stem.Scope stemScope, boolean findByUuidOrName, Subject subjectNotInGroup, Collection<String> groupIds, Collection<String> groupNames, Boolean compositeOwner)` get all groups secure, split the scope by whitespace
`Set<Group>`	`getAllGroupsSecure(String scope, GrouperSession grouperSession, Subject subject, Set<Privilege> privileges, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroups, boolean splitScope, Subject membershipSubject, Field field, String parentStemId, Stem.Scope stemScope, boolean findByUuidOrName, Subject subjectNotInGroup, Collection<String> groupIds, Collection<String> groupNames, Boolean compositeOwner, String idOfAttributeDefName, Object attributeValue)` get all groups secure, split the scope by whitespace
`Set<Group>`	getAllGroupsSecure(String scope, GrouperSession grouperSession, Subject subject, Set<Privilege> privileges, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroup, boolean splitScope, Subject membershipSubject, Field field, String parentStemId, Stem.Scope stemScope, boolean findByUuidOrName, Subject subjectNotInGroup, Collection<String> groupIds, Collection<String> groupNames, Boolean compositeOwner, String idOfAttributeDefName, Object attributeValue, Set<Object> attributeValuesOnAssignment, Boolean attributeCheckReadOnAttributeDef) get all groups secure, split the scope by whitespace
`Set<Group>`	getAllGroupsSecure(String scope, GrouperSession grouperSession, Subject subject, Set<Privilege> privileges, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroup, boolean splitScope, Subject membershipSubject, Field field, String parentStemId, Stem.Scope stemScope, boolean findByUuidOrName, Subject subjectNotInGroup, Collection<String> groupIds, Collection<String> groupNames, Boolean compositeOwner, String idOfAttributeDefName, Object attributeValue, Set<Object> attributeValuesOnAssignment, Boolean attributeCheckReadOnAttributeDef, String idOfAttributeDefName2, Object attributeValue2, Set<Object> attributeValuesOnAssignment2, boolean attributeNotAssigned) get all groups secure, split the scope by whitespace
`Set<Group>`	`getAllGroupsSplitScopeSecure(String scope, GrouperSession grouperSession, Subject subject, Set<Privilege> privileges, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroups)` get all groups secure, split the scope by whitespace
`Set<Group>`	`getAllGroupsSplitScopeSecure(String scope, GrouperSession grouperSession, Subject subject, Set<Privilege> privileges, QueryOptions queryOptions, TypeOfGroup typeOfGroup)` get all groups secure, split the scope by whitespace
`Set<Group>`	`getImmediateChildren(Stem stem)`
`Set<Group>`	`getImmediateChildrenMembershipSecure(GrouperSession grouperSession, Stem stem, Subject subject, Set<Privilege> inPrivSet, QueryOptions queryOptions, boolean enabledOnly)` get immediate children secure
`Set<Group>`	`getImmediateChildrenSecure(GrouperSession grouperSession, Stem stem, Subject subject, Set<Privilege> inPrivSet, QueryOptions queryOptions)` get immediate children secure
`Set<Group>`	`getImmediateChildrenSecure(GrouperSession grouperSession, Stem stem, Subject subject, Set<Privilege> inPrivSet, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroups)` get immediate children secure
`Set<Group>`	`getImmediateChildrenSecure(GrouperSession grouperSession, Stem stem, Subject subject, Set<Privilege> inPrivSet, QueryOptions queryOptions, Set<TypeOfGroup> typeOfGroups, Boolean enabled)` get immediate children secure
`static void`	`massageSortFields(QuerySort querySort)` if there are sort fields, go through them, and replace name with nameDb, etc, extension for extensionDb, displayName with displayNameDb, and displayExtension with displayExtensionDb
`static void`	`massageSortFields(QuerySort querySort, String alias)` if there are sort fields, go through them, and replace name with nameDb, etc, extension for extensionDb, displayName with displayNameDb, and displayExtension with displayExtensionDb
`void`	`putInExistsCache(String uuid, boolean exists)` put in cache
`protected static void`	`reset(HibernateSession hibernateSession)`
`void`	`saveUpdateProperties(Group group)` save the update properties which are auto saved when business method is called
`void`	`update(Group _g)`
`void`	`updateLastImmediateMembershipChange(String groupId)`
`void`	`updateLastMembershipChange(String groupId)`
`void`	`updateLastMembershipChangeIncludeAncestorGroups(String groupId)` This will update last_membership_change for group owners where group member in groupSet is the given groupId.

Methods inherited from class edu.internet2.middleware.grouper.internal.dao.hib3.Hib3DAO
evict, evictEntity, evictQueries, getConfiguration, getConfiguration, getSessionFactory, getSessionFactory, hibernateInitted, initHibernateIfNotInitted, initHibernateIfNotInitted, resourceNameFromClassName, session, session

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail
- Hib3GroupDAO
```
public Hib3GroupDAO()
```

Method Detail

putInExistsCache
```
public void putInExistsCache(String uuid,
                             boolean exists)
```
put in cache

Specified by:

putInExistsCache in interface GroupDAO

Parameters:

uuid -

exists -

delete
```
public void delete(Group _g)
            throws GrouperDAOException
```
Specified by:

delete in interface GroupDAO

Parameters:

_g -

Throws:

GrouperDAOException

Since:

@HEAD@

exists
```
public boolean exists(String uuid)
               throws GrouperDAOException
```
Specified by:

exists in interface GroupDAO

Parameters:

uuid -

Returns:

if exists

Throws:

GrouperDAOException

Since:

@HEAD@

findAllByAnyApproximateAttr

public Set<Group> findAllByAnyApproximateAttr(String val)
                                       throws GrouperDAOException,
                                              IllegalStateException

Specified by:: findAllByAnyApproximateAttr in interface GroupDAO
Parameters:: val -
Returns:: set
Throws:: GrouperDAOException; IllegalStateException
Since:: @HEAD@

findAllByAnyApproximateAttr

public Set<Group> findAllByAnyApproximateAttr(String val,
                                              String scope)
                                       throws GrouperDAOException,
                                              IllegalStateException

Specified by:: findAllByAnyApproximateAttr in interface GroupDAO
Parameters:: val -; scope -
Returns:: set
Throws:: GrouperDAOException; IllegalStateException
Since:: @HEAD@

findAllByAnyApproximateAttr

public Set<Group> findAllByAnyApproximateAttr(String val,
                                              String scope,
                                              boolean secureQuery)
                                       throws GrouperDAOException,
                                              IllegalStateException

Specified by:: findAllByAnyApproximateAttr in interface GroupDAO
Parameters:: val -; scope -; secureQuery -
Returns:: set
Throws:: GrouperDAOException; IllegalStateException
Since:: @HEAD@

findAllByAnyApproximateAttr

public Set<Group> findAllByAnyApproximateAttr(String val,
                                              String scope,
                                              boolean secureQuery,
                                              Boolean enabled)
                                       throws GrouperDAOException,
                                              IllegalStateException

Specified by:: findAllByAnyApproximateAttr in interface GroupDAO
Parameters:: val -; scope -; secureQuery -; enabled -
Returns:: set
Throws:: GrouperDAOException; IllegalStateException
Since:: @HEAD@

findAllByApproximateAttr
```
public Set<Group> findAllByApproximateAttr(String attr,
                                           String val)
                                    throws GrouperDAOException,
                                           IllegalStateException
```
Implementation Notes.
1. This method will generate a full table scan of the attributes table. It will not perform well if there are a large number of groups.
2. Hibernate caching is not enabled.
Specified by:

findAllByApproximateAttr in interface GroupDAO

Throws:

GrouperDAOException

IllegalStateException

Since:

@HEAD@

See Also:

GroupDAO.findAllByApproximateAttr(String, String)

findAllByApproximateAttr

public Set<Group> findAllByApproximateAttr(String attr,
                                           String val,
                                           String scope)
                                    throws GrouperDAOException,
                                           IllegalStateException

Implementation Notes.

This method will generate a full table scan of the attributes table. It will not perform well if there are a large number of groups.
Hibernate caching is not enabled.

Specified by:: findAllByApproximateAttr in interface GroupDAO
Throws:: GrouperDAOException; IllegalStateException
Since:: @HEAD@
See Also:: GroupDAO.findAllByApproximateAttr(String, String, String)

findAllByApproximateName
```
public Set<Group> findAllByApproximateName(String name)
                                    throws GrouperDAOException
```
Implementation Notes.
1. This method will generate a full table scan of the groups table. It will not perform well if there are a large number of groups.
2. Hibernate caching is not enabled.
Specified by:

findAllByApproximateName in interface GroupDAO

Throws:

GrouperDAOException

Since:

@HEAD@

See Also:

GroupDAO.findAllByApproximateName(String)

findAllByApproximateName
```
public Set<Group> findAllByApproximateName(String name,
                                           String scope)
                                    throws GrouperDAOException
```
Implementation Notes.
1. This method will generate a full table scan of the groups table. It will not perform well if there are a large number of groups.
2. Hibernate caching is not enabled.
Specified by:

findAllByApproximateName in interface GroupDAO

Throws:

GrouperDAOException

Since:

@HEAD@

See Also:

GroupDAO.findAllByApproximateName(String, String)

findAllByApproximateNameSecure
```
public Set<Group> findAllByApproximateNameSecure(String name,
                                                 String scope,
                                                 QueryOptions queryOptions)
                                          throws GrouperDAOException
```
Implementation Notes.
1. This method will generate a full table scan of the groups table. It will not perform well if there are a large number of groups.
2. Hibernate caching is not enabled.
Specified by:

findAllByApproximateNameSecure in interface GroupDAO

Parameters:

name -

scope -

queryOptions -

Returns:

the groups

Throws:

GrouperDAOException

Since:

@HEAD@

See Also:

GroupDAO.findAllByApproximateName(String, String)

findAllByApproximateNameSecure

public Set<Group> findAllByApproximateNameSecure(String name,
                                                 String scope,
                                                 QueryOptions queryOptions,
                                                 Set<TypeOfGroup> typeOfGroups)

Implementation Notes.

This method will generate a full table scan of the groups table. It will not perform well if there are a large number of groups.
Hibernate caching is not enabled.

Specified by:: findAllByApproximateNameSecure in interface GroupDAO
Parameters:: name -; scope -; queryOptions -; typeOfGroups -
Returns:: the groups
Throws:: GrouperDAOException
Since:: @HEAD@
See Also:: GroupDAO.findAllByApproximateName(String, String)

findAllByApproximateNameSecure

public Set<Group> findAllByApproximateNameSecure(String name,
                                                 String scope,
                                                 QueryOptions queryOptions,
                                                 Set<TypeOfGroup> typeOfGroups,
                                                 Boolean enabled)

Implementation Notes.

This method will generate a full table scan of the groups table. It will not perform well if there are a large number of groups.
Hibernate caching is not enabled.

Specified by:: findAllByApproximateNameSecure in interface GroupDAO
Parameters:: name -; scope -; queryOptions -; typeOfGroups -; enabled -
Returns:: the groups
Throws:: GrouperDAOException
Since:: @HEAD@
See Also:: GroupDAO.findAllByApproximateName(String, String)

findAllByApproximateCurrentName
```
public Set<Group> findAllByApproximateCurrentName(String name)
                                           throws GrouperDAOException
```
Find groups using an approximate string for the current name, display name, extension, display extension.

Specified by:

findAllByApproximateCurrentName in interface GroupDAO

Parameters:

name -

Returns:

set

Throws:

GrouperDAOException

findAllByApproximateCurrentName
```
public Set<Group> findAllByApproximateCurrentName(String name,
                                                  String scope)
                                           throws GrouperDAOException
```
Find groups using an approximate string for the current name, display name, extension, display extension.

Specified by:

findAllByApproximateCurrentName in interface GroupDAO

Parameters:

name -

scope -

Returns:

set

Throws:

GrouperDAOException

findAllByApproximateAlternateName
```
public Set<Group> findAllByApproximateAlternateName(String name)
                                             throws GrouperDAOException
```
Find groups using an approximate string for the alternate name.

Specified by:

findAllByApproximateAlternateName in interface GroupDAO

Parameters:

name -

Returns:

set

Throws:

GrouperDAOException

findAllByApproximateAlternateName

public Set<Group> findAllByApproximateAlternateName(String name,
                                                    String scope)
                                             throws GrouperDAOException

Find groups using an approximate string for the alternate name.

Specified by:: findAllByApproximateAlternateName in interface GroupDAO
Parameters:: name -; scope -
Returns:: set
Throws:: GrouperDAOException

massageSortFields
```
public static void massageSortFields(QuerySort querySort)
```
if there are sort fields, go through them, and replace name with nameDb, etc, extension for extensionDb, displayName with displayNameDb, and displayExtension with displayExtensionDb

Parameters:

querySort -

massageSortFields
```
public static void massageSortFields(QuerySort querySort,
                                     String alias)
```
if there are sort fields, go through them, and replace name with nameDb, etc, extension for extensionDb, displayName with displayNameDb, and displayExtension with displayExtensionDb

Parameters:

querySort -

alias - is the hql query alias

findAllByCreatedAfter
```
public Set<Group> findAllByCreatedAfter(Date d)
                                 throws GrouperDAOException
```
Specified by:

findAllByCreatedAfter in interface GroupDAO

Parameters:

d -

Returns:

set

Throws:

GrouperDAOException

Since:

@HEAD@

findAllByCreatedAfter

public Set<Group> findAllByCreatedAfter(Date d,
                                        String scope)

Specified by:: findAllByCreatedAfter in interface GroupDAO
Parameters:: d -; scope -
Returns:: set
Throws:: GrouperDAOException
Since:: @HEAD@

findAllByCreatedBefore
```
public Set<Group> findAllByCreatedBefore(Date d)
                                  throws GrouperDAOException
```
Specified by:

findAllByCreatedBefore in interface GroupDAO

Parameters:

d -

Returns:

set

Throws:

GrouperDAOException

Since:

@HEAD@

findAllByCreatedBefore

public Set<Group> findAllByCreatedBefore(Date d,
                                         String scope)
                                  throws GrouperDAOException

Specified by:: findAllByCreatedBefore in interface GroupDAO
Parameters:: d -; scope -
Returns:: set
Throws:: GrouperDAOException
Since:: @HEAD@

findAllByModifiedAfter
```
public Set<Group> findAllByModifiedAfter(Date d)
                                  throws GrouperDAOException
```
Specified by:

findAllByModifiedAfter in interface GroupDAO

Parameters:

d -

Returns:

set

Throws:

GrouperDAOException

Since:

@HEAD@

findAllByModifiedAfter

public Set<Group> findAllByModifiedAfter(Date d,
                                         String scope)
                                  throws GrouperDAOException

Specified by:: findAllByModifiedAfter in interface GroupDAO
Parameters:: d -; scope -
Returns:: set
Throws:: GrouperDAOException
Since:: @HEAD@

findAllByModifiedBefore
```
public Set<Group> findAllByModifiedBefore(Date d)
                                   throws GrouperDAOException
```
Specified by:

findAllByModifiedBefore in interface GroupDAO

Parameters:

d -

Returns:

set

Throws:

GrouperDAOException

Since:

@HEAD@

findAllByModifiedBefore

public Set<Group> findAllByModifiedBefore(Date d,
                                          String scope)
                                   throws GrouperDAOException

Specified by:: findAllByModifiedBefore in interface GroupDAO
Parameters:: d -; scope -
Returns:: set
Throws:: GrouperDAOException
Since:: @HEAD@

findAllByLastMembershipBefore
```
public Set<Group> findAllByLastMembershipBefore(Date d)
                                         throws GrouperDAOException
```
Specified by:

findAllByLastMembershipBefore in interface GroupDAO

Parameters:

d -

Returns:

set

Throws:

GrouperDAOException

Since:

@HEAD@

findAllByLastMembershipBefore

public Set<Group> findAllByLastMembershipBefore(Date d,
                                                String scope)
                                         throws GrouperDAOException

Specified by:: findAllByLastMembershipBefore in interface GroupDAO
Parameters:: d -; scope -
Returns:: set
Throws:: GrouperDAOException
Since:: @HEAD@

findAllByLastMembershipAfter
```
public Set<Group> findAllByLastMembershipAfter(Date d)
                                        throws GrouperDAOException
```
Specified by:

findAllByLastMembershipAfter in interface GroupDAO

Parameters:

d -

Returns:

set

Throws:

GrouperDAOException

Since:

@HEAD@

findAllByLastMembershipAfter

public Set<Group> findAllByLastMembershipAfter(Date d,
                                               String scope)
                                        throws GrouperDAOException

Specified by:: findAllByLastMembershipAfter in interface GroupDAO
Parameters:: d -; scope -
Returns:: set
Throws:: GrouperDAOException
Since:: @HEAD@

findAllByType
```
public Set<Group> findAllByType(GroupType _gt)
                         throws GrouperDAOException
```
Note, this doesnt cache

Specified by:

findAllByType in interface GroupDAO

Parameters:

_gt -

Returns:

set

Throws:

GrouperDAOException

Since:

@HEAD@

findAllByType

public Set<Group> findAllByType(GroupType _gt,
                                String scope)
                         throws GrouperDAOException

Specified by:: findAllByType in interface GroupDAO
Parameters:: _gt -; scope -
Returns:: set
Throws:: GrouperDAOException
Since:: @HEAD@

findByAttribute

public Group findByAttribute(String attr,
                             String val,
                             boolean exceptionIfNotFound,
                             boolean secureQuery)
                      throws GrouperDAOException,
                             GroupNotFoundException

Specified by:: findByAttribute in interface GroupDAO
Returns:: group
Throws:: GrouperDAOException; GroupNotFoundException
See Also:: GroupDAO.findByAttribute(java.lang.String, java.lang.String, boolean, boolean)

findByAttribute

public Group findByAttribute(String attr,
                             String val,
                             boolean exceptionIfNotFound)
                      throws GrouperDAOException,
                             GroupNotFoundException

Specified by:: findByAttribute in interface GroupDAO
Parameters:: attr -; val -; exceptionIfNotFound -
Returns:: group
Throws:: GrouperDAOException; GroupNotFoundException
Since:: @HEAD@

findByAttribute

@Deprecated
public Group findByAttribute(String attr,
                                         String val)
                                  throws GrouperDAOException,
                                         GroupNotFoundException

Deprecated. use overload

Specified by:: findByAttribute in interface GroupDAO
Parameters:: attr -; val -
Returns:: group
Throws:: GrouperDAOException; GroupNotFoundException

findByName

public Group findByName(String name,
                        boolean exceptionIfNotFound)
                 throws GrouperDAOException,
                        GroupNotFoundException

Specified by:: findByName in interface GroupDAO
Parameters:: name -; exceptionIfNotFound -
Returns:: group
Throws:: GrouperDAOException; GroupNotFoundException

findByName

public Group findByName(String name,
                        boolean exceptionIfNotFound,
                        QueryOptions queryOptions)
                 throws GrouperDAOException,
                        GroupNotFoundException

Specified by:: findByName in interface GroupDAO
Parameters:: name -; exceptionIfNotFound - exception if cant find group; queryOptions - if we should use cache or not
Returns:: group
Throws:: GrouperDAOException; GroupNotFoundException
Since:: @HEAD@

findByName

public Group findByName(String name,
                        boolean exceptionIfNotFound,
                        QueryOptions queryOptions,
                        Set<TypeOfGroup> typeOfGroups)
                 throws GrouperDAOException,
                        GroupNotFoundException

Specified by:: findByName in interface GroupDAO
Parameters:: name -; exceptionIfNotFound - exception if cant find group; queryOptions - if we should use cache or not
Returns:: group
Throws:: GrouperDAOException; GroupNotFoundException
Since:: @HEAD@

findByApproximateDescriptionSecure

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

Specified by:: findByApproximateDescriptionSecure in interface GroupDAO

findByDescriptionSecure

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

Specified by:: findByDescriptionSecure in interface GroupDAO

findByDisplayNameSecure

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

Specified by:: findByDisplayNameSecure in interface GroupDAO

findByApproximateDisplayNameSecure

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

Specified by:: findByApproximateDisplayNameSecure in interface GroupDAO

findByExtensionSecure

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

Specified by:: findByExtensionSecure in interface GroupDAO

findByApproximateExtensionSecure

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

Specified by:: findByApproximateExtensionSecure in interface GroupDAO

findByDisplayExtensionSecure

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

Specified by:: findByDisplayExtensionSecure in interface GroupDAO

findByApproximateDisplayExtensionSecure

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

Specified by:: findByApproximateDisplayExtensionSecure in interface GroupDAO

findByNameSecure

public Group findByNameSecure(String name,
                              boolean exceptionIfNotFound,
                              QueryOptions queryOptions,
                              Set<TypeOfGroup> typeOfGroups)

Specified by:: findByNameSecure in interface GroupDAO
Parameters:: name -; exceptionIfNotFound - exception if cant find group; queryOptions - if we should use cache or not
Returns:: group
Throws:: GrouperDAOException; GroupNotFoundException
Since:: @HEAD@

findByNameSecure

public Group findByNameSecure(String name,
                              boolean exceptionIfNotFound,
                              QueryOptions queryOptions,
                              Set<TypeOfGroup> typeOfGroups,
                              Set<Privilege> inPrivSet)

Specified by:: findByNameSecure in interface GroupDAO
Parameters:: name -; exceptionIfNotFound - exception if cant find group; queryOptions - if we should use cache or not; typeOfGroups -; inPrivSet -
Returns:: group
Throws:: GrouperDAOException; GroupNotFoundException
Since:: @HEAD@

findByCurrentName

public Group findByCurrentName(String name,
                               boolean exceptionIfNotFound)
                        throws GrouperDAOException,
                               GroupNotFoundException

Find a group by its current name only.

Specified by:: findByCurrentName in interface GroupDAO
Parameters:: name -; exceptionIfNotFound -
Returns:: group
Throws:: GrouperDAOException; GroupNotFoundException

findByAlternateName

public Group findByAlternateName(String name,
                                 boolean exceptionIfNotFound)
                          throws GrouperDAOException,
                                 GroupNotFoundException

Find a group by its alternate name only.

Specified by:: findByAlternateName in interface GroupDAO
Parameters:: name -; exceptionIfNotFound -
Returns:: group
Throws:: GrouperDAOException; GroupNotFoundException

findByName

@Deprecated
public Group findByName(String name)
                             throws GrouperDAOException,
                                    GroupNotFoundException

Deprecated. use overload

Specified by:: findByName in interface GroupDAO
Parameters:: name -
Returns:: group
Throws:: GrouperDAOException; GroupNotFoundException

findByUuid

@Deprecated
public Group findByUuid(String uuid)
                             throws GrouperDAOException,
                                    GroupNotFoundException

Deprecated. use overload

Hibernate caching is enabled.

Specified by:: findByUuid in interface GroupDAO
Throws:: GrouperDAOException; GroupNotFoundException
See Also:: GroupDAO.findByUuid(String)

findByUuid

public Group findByUuid(String uuid,
                        boolean exceptionIfNotFound)
                 throws GrouperDAOException,
                        GroupNotFoundException

Specified by:: findByUuid in interface GroupDAO
Throws:: GrouperDAOException; GroupNotFoundException
See Also:: GroupDAO.findByUuid(java.lang.String, boolean)

findByUuid

public Group findByUuid(String uuid,
                        boolean exceptionIfNotFound,
                        QueryOptions queryOptions)
                 throws GrouperDAOException,
                        GroupNotFoundException

Specified by:: findByUuid in interface GroupDAO
Returns:: the group or null or exception
Throws:: GrouperDAOException; GroupNotFoundException
See Also:: GroupDAO.findByUuid(java.lang.String, boolean, QueryOptions)

findByUuid

public Group findByUuid(String uuid,
                        boolean exceptionIfNotFound,
                        QueryOptions queryOptions,
                        Set<TypeOfGroup> typeOfGroups)
                 throws GrouperDAOException,
                        GroupNotFoundException

Specified by:: findByUuid in interface GroupDAO; typeOfGroups - to search in or null for all
Returns:: the group or null or exception
Throws:: GrouperDAOException; GroupNotFoundException
See Also:: GroupDAO.findByUuid(java.lang.String, boolean, QueryOptions, Set)

findByUuidSecure

public Group findByUuidSecure(String uuid,
                              boolean exceptionIfNotFound,
                              QueryOptions queryOptions,
                              Set<TypeOfGroup> typeOfGroups)
                       throws GrouperDAOException,
                              GroupNotFoundException

Description copied from interface: GroupDAO

find by uuid secure

Specified by:: findByUuidSecure in interface GroupDAO
Returns:: the group or null or exception
Throws:: GrouperDAOException; GroupNotFoundException
See Also:: GroupDAO.findByUuid(java.lang.String, boolean, QueryOptions, Set)

getAllGroups
```
public Set<Group> getAllGroups()
                        throws GrouperDAOException
```
Specified by:

getAllGroups in interface GroupDAO

Returns:

set

Throws:

GrouperDAOException

Since:

@HEAD@

getAllGroups
```
public Set<Group> getAllGroups(String scope)
                        throws GrouperDAOException
```
Specified by:

getAllGroups in interface GroupDAO

Parameters:

scope -

Returns:

set

Throws:

GrouperDAOException

Since:

@HEAD@

getImmediateChildren
```
public Set<Group> getImmediateChildren(Stem stem)
                                throws GrouperDAOException
```
Specified by:

getImmediateChildren in interface GroupDAO

Parameters:

stem -

Returns:

set

Throws:

GrouperDAOException

Since:

@HEAD@

update
```
public void update(Group _g)
            throws GrouperDAOException
```
Specified by:

update in interface GroupDAO

Parameters:

_g -

Throws:

GrouperDAOException

Since:

@HEAD@

reset

protected static void reset(HibernateSession hibernateSession)
                     throws org.hibernate.HibernateException

Parameters:: hibernateSession -
Throws:: org.hibernate.HibernateException

findAllByAttr

public Set<Group> findAllByAttr(String attr,
                                String val)
                         throws GrouperDAOException,
                                IllegalStateException

Implementation Notes.

This looks for groups by exact attribute value
Hibernate caching is not enabled.

Specified by:: findAllByAttr in interface GroupDAO
Throws:: GrouperDAOException; IllegalStateException
See Also:: GroupDAO.findAllByAttr(java.lang.String, java.lang.String)

findAllByAttr

public Set<Group> findAllByAttr(String attr,
                                String val,
                                String scope,
                                boolean secureQuery)
                         throws GrouperDAOException,
                                IllegalStateException

Specified by:: findAllByAttr in interface GroupDAO
Returns:: set
Throws:: GrouperDAOException; IllegalStateException
See Also:: GroupDAO.findAllByAttr(java.lang.String, java.lang.String, java.lang.String, boolean)

findAllByAttr

public Set<Group> findAllByAttr(String attr,
                                String val,
                                String scope,
                                boolean secureQuery,
                                Boolean enabled)
                         throws GrouperDAOException,
                                IllegalStateException

(non-Javadoc)

Specified by:: findAllByAttr in interface GroupDAO
Returns:: set
Throws:: GrouperDAOException; IllegalStateException
See Also:: GroupDAO.findAllByAttr(java.lang.String, java.lang.String, java.lang.String, boolean, java.lang.Boolean)

findAllByAttr

public Set<Group> findAllByAttr(String attr,
                                String val,
                                String scope)
                         throws GrouperDAOException,
                                IllegalStateException

Implementation Notes.

This looks for groups by exact attribute value
Hibernate caching is not enabled.

Specified by:: findAllByAttr in interface GroupDAO
Throws:: GrouperDAOException; IllegalStateException
See Also:: GroupDAO.findAllByAttr(java.lang.String, java.lang.String, java.lang.String)

findByCreatorOrModifier
```
public Set<Group> findByCreatorOrModifier(Member member)
```
find groups by creator or modifier

Specified by:

findByCreatorOrModifier in interface GroupDAO

Parameters:

member -

Returns:

the groups

getAllGroupsSecure

public Set<Group> getAllGroupsSecure(GrouperSession grouperSession,
                                     Subject subject,
                                     Set<Privilege> inPrivSet,
                                     QueryOptions queryOptions)
                              throws GrouperDAOException

Specified by:: getAllGroupsSecure in interface GroupDAO; inPrivSet - means that each row must have a matching priv in this set to user or GrouperAll. There are some constants in AccessPrivilege of pre-canned sets
Returns:: groups
Throws:: GrouperDAOException
See Also:: GroupDAO.getAllGroupsSecure(GrouperSession, Subject, Set, QueryOptions, Set)

getAllGroupsSecure

public Set<Group> getAllGroupsSecure(GrouperSession grouperSession,
                                     Subject subject,
                                     Set<Privilege> inPrivSet,
                                     QueryOptions queryOptions,
                                     Set<TypeOfGroup> typeOfGroups)
                              throws GrouperDAOException

In this case, send in the attribute name to sort by (default is displayName). Make sure the grouperSession can see the groups

Specified by:: getAllGroupsSecure in interface GroupDAO
Parameters:: grouperSession -; subject -; queryOptions -; inPrivSet - means that each row must have a matching priv in this set to user or GrouperAll. There are some constants in AccessPrivilege of pre-canned sets; typeOfGroups - type of groups to return, or null for all
Returns:: set
Throws:: GrouperDAOException

getAllGroupsSecure

public Set<Group> getAllGroupsSecure(GrouperSession grouperSession,
                                     Subject subject,
                                     Set<Privilege> inPrivSet,
                                     QueryOptions queryOptions,
                                     Set<TypeOfGroup> typeOfGroups,
                                     Boolean enabled)
                              throws GrouperDAOException

In this case, send in the attribute name to sort by (default is displayName). Make sure the grouperSession can see the groups

Specified by:: getAllGroupsSecure in interface GroupDAO
Parameters:: grouperSession -; subject -; queryOptions -; inPrivSet - means that each row must have a matching priv in this set to user or GrouperAll. There are some constants in AccessPrivilege of pre-canned sets; enabled -; typeOfGroups - type of groups to return, or null for all
Returns:: set
Throws:: GrouperDAOException

getAllGroupsSecure

public Set<Group> getAllGroupsSecure(String scope,
                                     GrouperSession grouperSession,
                                     Subject subject,
                                     Set<Privilege> inPrivSet,
                                     QueryOptions queryOptions)
                              throws GrouperDAOException

Specified by:: getAllGroupsSecure in interface GroupDAO; inPrivSet - means that each row must have a matching priv in this set to user or GrouperAll. There are some constants in AccessPrivilege of pre-canned sets
Returns:: the groups
Throws:: GrouperDAOException
See Also:: GroupDAO.getAllGroupsSecure(java.lang.String, edu.internet2.middleware.grouper.GrouperSession, edu.internet2.middleware.subject.Subject, java.util.Set, edu.internet2.middleware.grouper.internal.dao.QueryOptions)

getAllGroupsSecure

public Set<Group> getAllGroupsSecure(String scope,
                                     GrouperSession grouperSession,
                                     Subject subject,
                                     Set<Privilege> inPrivSet,
                                     QueryOptions queryOptions,
                                     Set<TypeOfGroup> typeOfGroups)
                              throws GrouperDAOException

Specified by:: getAllGroupsSecure in interface GroupDAO; inPrivSet - means that each row must have a matching priv in this set to user or GrouperAll. There are some constants in AccessPrivilege of pre-canned sets; typeOfGroups - type of groups to return or null for all
Returns:: the groups
Throws:: GrouperDAOException
See Also:: GroupDAO.getAllGroupsSecure(java.lang.String, edu.internet2.middleware.grouper.GrouperSession, edu.internet2.middleware.subject.Subject, java.util.Set, edu.internet2.middleware.grouper.internal.dao.QueryOptions, Set)

getAllGroupsSecure

public Set<Group> getAllGroupsSecure(String scope,
                                     GrouperSession grouperSession,
                                     Subject subject,
                                     Set<Privilege> inPrivSet,
                                     QueryOptions queryOptions,
                                     Set<TypeOfGroup> typeOfGroups,
                                     Boolean enabled)
                              throws GrouperDAOException

Specified by:: getAllGroupsSecure in interface GroupDAO; inPrivSet - means that each row must have a matching priv in this set to user or GrouperAll. There are some constants in AccessPrivilege of pre-canned sets; typeOfGroups - type of groups to return or null for all
Returns:: the groups
Throws:: GrouperDAOException
See Also:: GroupDAO.getAllGroupsSecure(java.lang.String, edu.internet2.middleware.grouper.GrouperSession, edu.internet2.middleware.subject.Subject, java.util.Set, edu.internet2.middleware.grouper.internal.dao.QueryOptions, java.util.Set, java.lang.Boolean)

getImmediateChildrenSecure
```
public Set<Group> getImmediateChildrenSecure(GrouperSession grouperSession,
                                             Stem stem,
                                             Subject subject,
                                             Set<Privilege> inPrivSet,
                                             QueryOptions queryOptions)
                                      throws GrouperDAOException
```
Description copied from interface: GroupDAO

get immediate children secure

Specified by:

getImmediateChildrenSecure in interface GroupDAO

inPrivSet - means that each row must have a matching priv in this set to user or GrouperAll. There are some constants in AccessPrivilege of pre-canned sets

Returns:

the set of groups

Throws:

GrouperDAOException

See Also:

GroupDAO.getImmediateChildrenSecure(edu.internet2.middleware.grouper.GrouperSession, edu.internet2.middleware.grouper.Stem, edu.internet2.middleware.subject.Subject, java.util.Set, edu.internet2.middleware.grouper.internal.dao.QueryOptions)

getImmediateChildrenSecure

public Set<Group> getImmediateChildrenSecure(GrouperSession grouperSession,
                                             Stem stem,
                                             Subject subject,
                                             Set<Privilege> inPrivSet,
                                             QueryOptions queryOptions,
                                             Set<TypeOfGroup> typeOfGroups)
                                      throws GrouperDAOException

Description copied from interface: GroupDAO

get immediate children secure

Specified by:: getImmediateChildrenSecure in interface GroupDAO; inPrivSet - means that each row must have a matching priv in this set to user or GrouperAll. There are some constants in AccessPrivilege of pre-canned sets; typeOfGroups - type of groups to return, or null for all
Returns:: the set of groups
Throws:: GrouperDAOException
See Also:: GroupDAO.getImmediateChildrenSecure(edu.internet2.middleware.grouper.GrouperSession, edu.internet2.middleware.grouper.Stem, edu.internet2.middleware.subject.Subject, java.util.Set, edu.internet2.middleware.grouper.internal.dao.QueryOptions, Set)

getImmediateChildrenSecure

public Set<Group> getImmediateChildrenSecure(GrouperSession grouperSession,
                                             Stem stem,
                                             Subject subject,
                                             Set<Privilege> inPrivSet,
                                             QueryOptions queryOptions,
                                             Set<TypeOfGroup> typeOfGroups,
                                             Boolean enabled)
                                      throws GrouperDAOException

Description copied from interface: GroupDAO

get immediate children secure

Specified by:: getImmediateChildrenSecure in interface GroupDAO; inPrivSet - means that each row must have a matching priv in this set to user or GrouperAll. There are some constants in AccessPrivilege of pre-canned sets; typeOfGroups - type of groups to return, or null for all
Returns:: the set of groups
Throws:: GrouperDAOException
See Also:: GroupDAO.getImmediateChildrenSecure(edu.internet2.middleware.grouper.GrouperSession, edu.internet2.middleware.grouper.Stem, edu.internet2.middleware.subject.Subject, java.util.Set, edu.internet2.middleware.grouper.internal.dao.QueryOptions, java.util.Set, java.lang.Boolean)

findByUuids
```
public Set<Group> findByUuids(Collection<String> uuids,
                              boolean exceptionOnNotFound)
                       throws GroupNotFoundException
```
Description copied from interface: GroupDAO

find all groups which have these uuids

Specified by:

findByUuids in interface GroupDAO

exceptionOnNotFound - if exception should be thrown when a uuid doesnt match up

Returns:

the groups

Throws:

GroupNotFoundException

See Also:

GroupDAO.findByUuids(java.util.Collection, boolean)

getAllGroupsMembershipSecure

public Set<Group> getAllGroupsMembershipSecure(GrouperSession grouperSession,
                                               Subject subject,
                                               Set<Privilege> inPrivSet,
                                               QueryOptions queryOptions,
                                               boolean enabledOnly)
                                        throws GrouperDAOException

Specified by:: getAllGroupsMembershipSecure in interface GroupDAO; inPrivSet - means that each row must have a matching priv in this set to user or GrouperAll. There are some constants in AccessPrivilege of pre-canned sets
Returns:: groups
Throws:: GrouperDAOException
See Also:: GroupDAO.getAllGroupsMembershipSecure(edu.internet2.middleware.grouper.GrouperSession, edu.internet2.middleware.subject.Subject, java.util.Set, edu.internet2.middleware.grouper.internal.dao.QueryOptions, boolean)

getAllGroupsMembershipSecure

public Set<Group> getAllGroupsMembershipSecure(String scope,
                                               GrouperSession grouperSession,
                                               Subject subject,
                                               Set<Privilege> inPrivSet,
                                               QueryOptions queryOptions,
                                               boolean enabledOnly)
                                        throws GrouperDAOException

Specified by:: getAllGroupsMembershipSecure in interface GroupDAO; inPrivSet - means that each row must have a matching priv in this set to user or GrouperAll. There are some constants in AccessPrivilege of pre-canned sets
Returns:: the groups
Throws:: GrouperDAOException
See Also:: GroupDAO.getAllGroupsMembershipSecure(java.lang.String, edu.internet2.middleware.grouper.GrouperSession, edu.internet2.middleware.subject.Subject, java.util.Set, edu.internet2.middleware.grouper.internal.dao.QueryOptions, boolean)

getAllGroupsMembershipSecure

public Set<Group> getAllGroupsMembershipSecure(String scope,
                                               GrouperSession grouperSession,
                                               Subject subject,
                                               Set<Privilege> inPrivSet,
                                               QueryOptions queryOptions,
                                               boolean enabledOnly,
                                               Stem stem,
                                               Stem.Scope stemScope)
                                        throws GrouperDAOException

Specified by:: getAllGroupsMembershipSecure in interface GroupDAO; inPrivSet - means that each row must have a matching priv in this set to user or GrouperAll. There are some constants in AccessPrivilege of pre-canned sets
Returns:: the groups
Throws:: GrouperDAOException
See Also:: GroupDAO.getAllGroupsMembershipSecure(java.lang.String, edu.internet2.middleware.grouper.GrouperSession, edu.internet2.middleware.subject.Subject, java.util.Set, edu.internet2.middleware.grouper.internal.dao.QueryOptions, boolean, edu.internet2.middleware.grouper.Stem, edu.internet2.middleware.grouper.Stem.Scope)

getImmediateChildrenMembershipSecure

public Set<Group> getImmediateChildrenMembershipSecure(GrouperSession grouperSession,
                                                       Stem stem,
                                                       Subject subject,
                                                       Set<Privilege> inPrivSet,
                                                       QueryOptions queryOptions,
                                                       boolean enabledOnly)
                                                throws GrouperDAOException

Description copied from interface: GroupDAO

get immediate children secure

Specified by:: getImmediateChildrenMembershipSecure in interface GroupDAO; inPrivSet - means that each row must have a matching priv in this set to user or GrouperAll. There are some constants in AccessPrivilege of pre-canned sets
Returns:: the set of groups
Throws:: GrouperDAOException
See Also:: GroupDAO.getImmediateChildrenMembershipSecure(edu.internet2.middleware.grouper.GrouperSession, edu.internet2.middleware.grouper.Stem, edu.internet2.middleware.subject.Subject, java.util.Set, edu.internet2.middleware.grouper.internal.dao.QueryOptions, boolean)

updateLastMembershipChange
```
public void updateLastMembershipChange(String groupId)
```
Specified by:

updateLastMembershipChange in interface GroupDAO

See Also:

GroupDAO.updateLastMembershipChange(java.lang.String)

updateLastImmediateMembershipChange
```
public void updateLastImmediateMembershipChange(String groupId)
```
Specified by:

updateLastImmediateMembershipChange in interface GroupDAO

See Also:

GroupDAO.updateLastImmediateMembershipChange(java.lang.String)

updateLastMembershipChangeIncludeAncestorGroups
```
public void updateLastMembershipChangeIncludeAncestorGroups(String groupId)
```
Description copied from interface: GroupDAO

This will update last_membership_change for group owners where group member in groupSet is the given groupId.

Specified by:

updateLastMembershipChangeIncludeAncestorGroups in interface GroupDAO

See Also:

GroupDAO.updateLastMembershipChangeIncludeAncestorGroups(java.lang.String)

getAllGroupsMembershipSecure

public Set<Group> getAllGroupsMembershipSecure(Field field,
                                               String scope,
                                               GrouperSession grouperSession,
                                               Subject subject,
                                               QueryOptions queryOptions,
                                               Boolean enabled,
                                               MembershipType membershipType,
                                               Stem stem,
                                               Stem.Scope stemScope)
                                        throws GrouperDAOException

Specified by:: getAllGroupsMembershipSecure in interface GroupDAO; queryOptions - if sorting on name, displayName, extension, displayExtension; enabled - null for all, True for enabledOnly, False for disabledOnly; membershipType - immediate, effective, etc; stem - if searching in a specific stem; stemScope - sub or one
Returns:: the groups
Throws:: GrouperDAOException
See Also:: edu.internet2.middleware.grouper.internal.dao.GroupDAO#getAllGroupsMembershipSecure(java.lang.String, edu.internet2.middleware.grouper.GrouperSession, edu.internet2.middleware.subject.Subject, edu.internet2.middleware.grouper.internal.dao.QueryOptions, java.lang.Boolean, edu.internet2.middleware.grouper.membership.MembershipType, edu.internet2.middleware.grouper.Stem, edu.internet2.middleware.grouper.Stem.Scope)

findByUuidOrName

public Group findByUuidOrName(String uuid,
                              String name,
                              boolean exceptionIfNull)
                       throws GrouperDAOException,
                              GroupNotFoundException

Specified by:: findByUuidOrName in interface GroupDAO
Returns:: the stem or null
Throws:: GrouperDAOException; GroupNotFoundException
See Also:: GroupDAO.findByUuidOrName(java.lang.String, java.lang.String, boolean)

findByUuidOrName

public Group findByUuidOrName(String uuid,
                              String name,
                              boolean exceptionIfNull,
                              QueryOptions queryOptions)
                       throws GrouperDAOException,
                              GroupNotFoundException

Specified by:: findByUuidOrName in interface GroupDAO
Returns:: the stem or null
Throws:: GrouperDAOException; GroupNotFoundException
See Also:: GroupDAO.findByUuidOrName(java.lang.String, java.lang.String, boolean, QueryOptions)

saveUpdateProperties
```
public void saveUpdateProperties(Group group)
```
Description copied from interface: GroupDAO

save the update properties which are auto saved when business method is called

Specified by:

saveUpdateProperties in interface GroupDAO

See Also:

GroupDAO.saveUpdateProperties(edu.internet2.middleware.grouper.Group)

findAllByType

public Set<Group> findAllByType(GroupType _gt,
                                QueryOptions queryOptions)
                         throws GrouperDAOException

Description copied from interface: GroupDAO

this caches

Specified by:: findAllByType in interface GroupDAO
Throws:: GrouperDAOException
See Also:: GroupDAO.findAllByType(GroupType, QueryOptions)

findGroupsInStemWithoutPrivilege

public Set<Group> findGroupsInStemWithoutPrivilege(GrouperSession grouperSession,
                                                   String stemId,
                                                   Stem.Scope scope,
                                                   Subject subject,
                                                   Privilege privilege,
                                                   QueryOptions queryOptions,
                                                   boolean considerAllSubject,
                                                   String sqlLikeString)

Description copied from interface: GroupDAO

see which groups do not have this privilege

Specified by:: findGroupsInStemWithoutPrivilege in interface GroupDAO
Returns:: the groups
See Also:: GroupDAO#findGroupsInStemWithoutPrivilege(GrouperSession, String, Scope, Subject, Privilege, QueryOptions, boolean, String)

getAllGroupsSplitScopeSecure

public Set<Group> getAllGroupsSplitScopeSecure(String scope,
                                               GrouperSession grouperSession,
                                               Subject subject,
                                               Set<Privilege> privileges,
                                               QueryOptions queryOptions,
                                               TypeOfGroup typeOfGroup)

Description copied from interface: GroupDAO

get all groups secure, split the scope by whitespace

Specified by:: getAllGroupsSplitScopeSecure in interface GroupDAO; typeOfGroup - or null for all
Returns:: set of group
See Also:: GroupDAO.getAllGroupsSplitScopeSecure(String, GrouperSession, Subject, Set, QueryOptions, TypeOfGroup)

getAllGroupsSplitScopeSecure

public Set<Group> getAllGroupsSplitScopeSecure(String scope,
                                               GrouperSession grouperSession,
                                               Subject subject,
                                               Set<Privilege> privileges,
                                               QueryOptions queryOptions,
                                               Set<TypeOfGroup> typeOfGroups)

Description copied from interface: GroupDAO

get all groups secure, split the scope by whitespace

Specified by:: getAllGroupsSplitScopeSecure in interface GroupDAO; typeOfGroups - or null for all
Returns:: set of group
See Also:: GroupDAO.getAllGroupsSplitScopeSecure(String, GrouperSession, Subject, Set, QueryOptions, Set)

assignFilterToQuery

public static String assignFilterToQuery(String filter,
                                         Boolean splitScope,
                                         StringBuilder whereClause,
                                         ByHqlStatic byHqlStatic,
                                         boolean findByUuidOrName,
                                         String alias,
                                         boolean addFinalParen)

Parameters:: byHqlStatic -; filter -; splitScope - default true; whereClause -; findByUuidOrName - generally this is false; alias - e.g. theGroup whatever alias in hql query; addFinalParen -
Returns:: scope lowercased

findAllByApproximateAttrSecure

public Set<Group> findAllByApproximateAttrSecure(String attr,
                                                 String val,
                                                 String scope,
                                                 Boolean enabled)
                                          throws GrouperDAOException,
                                                 IllegalStateException

Specified by:: findAllByApproximateAttrSecure in interface GroupDAO
Parameters:: attr - attribute name; val - value; scope - some folder or null for all
Returns:: the grops
Throws:: GrouperDAOException; IllegalStateException
See Also:: GroupDAO.findAllByApproximateAttrSecure(java.lang.String, java.lang.String, java.lang.String, java.lang.Boolean)

findAllByApproximateAttrSecure

public Set<Group> findAllByApproximateAttrSecure(String attr,
                                                 String val,
                                                 String scope)
                                          throws GrouperDAOException,
                                                 IllegalStateException

Specified by:: findAllByApproximateAttrSecure in interface GroupDAO
Parameters:: attr - attribute name; val - value; scope - some folder or null for all
Returns:: the grops
Throws:: GrouperDAOException; IllegalStateException
See Also:: GroupDAO.findAllByApproximateAttrSecure(java.lang.String, java.lang.String, java.lang.String)

findByNamesSecure

public Set<Group> findByNamesSecure(Collection<String> names,
                                    QueryOptions queryOptions)

Specified by:: findByNamesSecure in interface GroupDAO
See Also:: GroupDAO.findByNamesSecure(Collection, QueryOptions)

findByNamesSecure

public Set<Group> findByNamesSecure(Collection<String> names,
                                    QueryOptions queryOptions,
                                    Set<TypeOfGroup> typeOfGroups)

Specified by:: findByNamesSecure in interface GroupDAO
See Also:: GroupDAO.findByNamesSecure(Collection, QueryOptions)

findByUuidsSecure
```
public Set<Group> findByUuidsSecure(Collection<String> uuids,
                                    QueryOptions queryOptions)
```
Description copied from interface: GroupDAO

find by uuid secure

Specified by:

findByUuidsSecure in interface GroupDAO

Returns:

the group or null or exception

See Also:

GroupDAO.findByUuidsSecure(Collection, QueryOptions)

findByUuidsSecure

public Set<Group> findByUuidsSecure(Collection<String> uuids,
                                    QueryOptions queryOptions,
                                    Set<TypeOfGroup> typeOfGroups)

Description copied from interface: GroupDAO

find by uuid secure

Specified by:: findByUuidsSecure in interface GroupDAO
Returns:: the group or null or exception
See Also:: GroupDAO.findByUuidsSecure(Collection, QueryOptions, Set)

findByIdIndex

public Group findByIdIndex(Long idIndex,
                           boolean exceptionIfNotFound)
                    throws GroupNotFoundException

not a secure method, find by id index

Specified by:: findByIdIndex in interface GroupDAO
Throws:: GroupNotFoundException

findByIdIndexSecure
```
public Group findByIdIndexSecure(Long idIndex,
                                 boolean exceptionIfNotFound,
                                 QueryOptions queryOptions)
                          throws GroupNotFoundException
```
Description copied from interface: GroupDAO

find a group by id index

Specified by:

findByIdIndexSecure in interface GroupDAO

Parameters:

idIndex - id index to find

exceptionIfNotFound - true if exception should be thrown if not found

queryOptions - query options

Returns:

the gorup or null or exception

Throws:

GroupNotFoundException

See Also:

GroupDAO.findByIdIndexSecure(Long, boolean, QueryOptions)

getAllGroupsSecure

public Set<Group> getAllGroupsSecure(String scope,
                                     GrouperSession grouperSession,
                                     Subject subject,
                                     Set<Privilege> privileges,
                                     QueryOptions queryOptions,
                                     Set<TypeOfGroup> typeOfGroups,
                                     boolean splitScope,
                                     Subject membershipSubject,
                                     Field field)

Description copied from interface: GroupDAO

get all groups secure, split the scope by whitespace

Specified by:: getAllGroupsSecure in interface GroupDAO; typeOfGroups - or null for all
Returns:: set of group
See Also:: GroupDAO.getAllGroupsSecure(java.lang.String, edu.internet2.middleware.grouper.GrouperSession, edu.internet2.middleware.subject.Subject, java.util.Set, edu.internet2.middleware.grouper.internal.dao.QueryOptions, java.util.Set, boolean, edu.internet2.middleware.subject.Subject, edu.internet2.middleware.grouper.Field)

getAllGroupsSecure

public Set<Group> getAllGroupsSecure(String scope,
                                     GrouperSession grouperSession,
                                     Subject subject,
                                     Set<Privilege> privileges,
                                     QueryOptions queryOptions,
                                     Set<TypeOfGroup> typeOfGroups,
                                     boolean splitScope,
                                     Subject membershipSubject,
                                     Field field,
                                     String parentStemId,
                                     Stem.Scope stemScope,
                                     boolean findByUuidOrName,
                                     Subject subjectNotInGroup,
                                     Collection<String> groupIds,
                                     Collection<String> groupNames,
                                     Boolean compositeOwner)

Description copied from interface: GroupDAO

get all groups secure, split the scope by whitespace

Specified by:: getAllGroupsSecure in interface GroupDAO; typeOfGroups - or null for all; subjectNotInGroup - is a subject which does not have a membership in the group; groupIds - are the group ids to search for; groupNames - are the group names to search for; compositeOwner - if we are filtering for groups which are or are not composite owners
Returns:: set of group
See Also:: GroupDAO#getAllGroupsSecure(String, GrouperSession, Subject, Set, QueryOptions, Set, boolean, Subject, Field, String, Scope, boolean, Subject, Collection, Collection, Boolean)

getAllGroupsSecure

public Set<Group> getAllGroupsSecure(String scope,
                                     GrouperSession grouperSession,
                                     Subject subject,
                                     Set<Privilege> privileges,
                                     QueryOptions queryOptions,
                                     Set<TypeOfGroup> typeOfGroups,
                                     boolean splitScope,
                                     Subject membershipSubject,
                                     Field field,
                                     String parentStemId,
                                     Stem.Scope stemScope,
                                     boolean findByUuidOrName,
                                     Subject subjectNotInGroup,
                                     Collection<String> groupIds,
                                     Collection<String> groupNames,
                                     Boolean compositeOwner,
                                     String idOfAttributeDefName,
                                     Object attributeValue)

Description copied from interface: GroupDAO

get all groups secure, split the scope by whitespace

Specified by:: getAllGroupsSecure in interface GroupDAO; typeOfGroups - or null for all; subjectNotInGroup - is a subject which does not have a membership in the group; groupIds - are the group ids to search for; groupNames - are the group names to search for; compositeOwner - if we are filtering for groups which are or are not composite owners; idOfAttributeDefName - if looking for groups that have this attribute def name; attributeValue - if looking for groups that have this attribute value on the attribute def name
Returns:: set of group
See Also:: GroupDAO#getAllGroupsSecure(String, GrouperSession, Subject, Set, QueryOptions, Set, boolean, Subject, Field, String, Scope, boolean, Subject, Collection, Collection, Boolean, String, Object)

getAllGroupsSecure

public Set<Group> getAllGroupsSecure(String scope,
                                     GrouperSession grouperSession,
                                     Subject subject,
                                     Set<Privilege> privileges,
                                     QueryOptions queryOptions,
                                     Set<TypeOfGroup> typeOfGroup,
                                     boolean splitScope,
                                     Subject membershipSubject,
                                     Field field,
                                     String parentStemId,
                                     Stem.Scope stemScope,
                                     boolean findByUuidOrName,
                                     Subject subjectNotInGroup,
                                     Collection<String> groupIds,
                                     Collection<String> groupNames,
                                     Boolean compositeOwner,
                                     String idOfAttributeDefName,
                                     Object attributeValue,
                                     Set<Object> attributeValuesOnAssignment,
                                     Boolean attributeCheckReadOnAttributeDef)

Description copied from interface: GroupDAO

get all groups secure, split the scope by whitespace

Specified by:: getAllGroupsSecure in interface GroupDAO; typeOfGroup - or null for all; subjectNotInGroup - is a subject which does not have a membership in the group; groupIds - are the group ids to search for; groupNames - are the group names to search for; compositeOwner - if we are filtering for groups which are or are not composite owners; idOfAttributeDefName - if looking for groups that have this attribute def name; attributeValue - if looking for groups that have this attribute value on the attribute def name; attributeValuesOnAssignment - if looking for an attribute value on an assignment, could be multiple values; attributeCheckReadOnAttributeDef - use security around attribute def? default is true
Returns:: set of group
See Also:: GroupDAO#getAllGroupsSecure(String, GrouperSession, Subject, Set, QueryOptions, Set, boolean, Subject, Field, String, Scope, boolean, Subject, Collection, Collection, Boolean, String, Object, Set, Boolean)

findGroupsInStemWithPrivilege

public Set<Group> findGroupsInStemWithPrivilege(GrouperSession grouperSession,
                                                String stemId,
                                                Stem.Scope scope,
                                                Subject subject,
                                                Privilege privilege,
                                                QueryOptions queryOptions,
                                                boolean considerAllSubject,
                                                String sqlLikeString)

Description copied from interface: GroupDAO

see which groups do not have this privilege

Specified by:: findGroupsInStemWithPrivilege in interface GroupDAO
Returns:: the groups
See Also:: GroupDAO#findGroupsInStemWithPrivilege(GrouperSession, String, Scope, Subject, Privilege, QueryOptions, boolean, String)

getAllGroupsSecure

public Set<Group> getAllGroupsSecure(String scope,
                                     GrouperSession grouperSession,
                                     Subject subject,
                                     Set<Privilege> privileges,
                                     QueryOptions queryOptions,
                                     Set<TypeOfGroup> typeOfGroup,
                                     boolean splitScope,
                                     Subject membershipSubject,
                                     Field field,
                                     String parentStemId,
                                     Stem.Scope stemScope,
                                     boolean findByUuidOrName,
                                     Subject subjectNotInGroup,
                                     Collection<String> groupIds,
                                     Collection<String> groupNames,
                                     Boolean compositeOwner,
                                     String idOfAttributeDefName,
                                     Object attributeValue,
                                     Set<Object> attributeValuesOnAssignment,
                                     Boolean attributeCheckReadOnAttributeDef,
                                     String idOfAttributeDefName2,
                                     Object attributeValue2,
                                     Set<Object> attributeValuesOnAssignment2,
                                     boolean attributeNotAssigned)

Description copied from interface: GroupDAO

get all groups secure, split the scope by whitespace

Specified by:: getAllGroupsSecure in interface GroupDAO; typeOfGroup - or null for all; subjectNotInGroup - is a subject which does not have a membership in the group; groupIds - are the group ids to search for; groupNames - are the group names to search for; compositeOwner - if we are filtering for groups which are or are not composite owners; idOfAttributeDefName - if looking for groups that have this attribute def name; attributeValue - if looking for groups that have this attribute value on the attribute def name; attributeValuesOnAssignment - if looking for an attribute value on an assignment, could be multiple values; attributeCheckReadOnAttributeDef - use security around attribute def? default is true; idOfAttributeDefName2 - if looking for groups that have this attribute def name2; attributeValue2 - if looking for groups that have this attribute value2 on the attribute def name2; attributeValuesOnAssignment2 - if looking for an attribute value on an assignment2, could be multiple values
Returns:: set of group
See Also:: GroupDAO#getAllGroupsSecure(String, GrouperSession, Subject, Set, QueryOptions, Set, boolean, Subject, Field, String, Scope, boolean, Subject, Collection, Collection, Boolean, String, Object, Set, Boolean, String, Object)

findAllEnabledDisabledMismatch
```
public Set<Group> findAllEnabledDisabledMismatch()
```
Description copied from interface: GroupDAO

find records which are disabled which shouldnt be, and enabled which shouldnt be

Specified by:

findAllEnabledDisabledMismatch in interface GroupDAO

Returns:

the groups

See Also:

GroupDAO.findAllEnabledDisabledMismatch()

Class Hib3GroupDAO

Constructor Summary

Method Summary

Methods inherited from class edu.internet2.middleware.grouper.internal.dao.hib3.Hib3DAO

Methods inherited from class java.lang.Object

Constructor Detail

Hib3GroupDAO

Method Detail

putInExistsCache

delete

exists

findAllByAnyApproximateAttr

findAllByAnyApproximateAttr

findAllByAnyApproximateAttr

findAllByAnyApproximateAttr

findAllByApproximateAttr

findAllByApproximateAttr

findAllByApproximateName

findAllByApproximateName

findAllByApproximateNameSecure

findAllByApproximateNameSecure

findAllByApproximateNameSecure

findAllByApproximateCurrentName

findAllByApproximateCurrentName

findAllByApproximateAlternateName

findAllByApproximateAlternateName

massageSortFields

massageSortFields

findAllByCreatedAfter

findAllByCreatedAfter

findAllByCreatedBefore

findAllByCreatedBefore

findAllByModifiedAfter

findAllByModifiedAfter

findAllByModifiedBefore

findAllByModifiedBefore

findAllByLastMembershipBefore

findAllByLastMembershipBefore

findAllByLastMembershipAfter

findAllByLastMembershipAfter

findAllByType

findAllByType

findByAttribute

findByAttribute

findByAttribute

findByName

findByName

findByName

findByApproximateDescriptionSecure

findByDescriptionSecure

findByDisplayNameSecure

findByApproximateDisplayNameSecure

findByExtensionSecure

findByApproximateExtensionSecure

findByDisplayExtensionSecure

findByApproximateDisplayExtensionSecure

findByNameSecure

findByNameSecure

findByCurrentName

findByAlternateName

findByName

findByUuid

findByUuid

findByUuid

findByUuid

findByUuidSecure

getAllGroups

getAllGroups

getImmediateChildren

update

reset

findAllByAttr

findAllByAttr

findAllByAttr

findAllByAttr

findByCreatorOrModifier

getAllGroupsSecure

getAllGroupsSecure

getAllGroupsSecure

getAllGroupsSecure