Hib3MembershipDAO (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.Hib3MembershipDAO

All Implemented Interfaces:

GrouperDAO, MembershipDAO
```
public class Hib3MembershipDAO
extends Hib3DAO
implements MembershipDAO
```
Basic Hibernate Membership DAO interface.

Since:

@HEAD@

Version:

$Id: Hib3MembershipDAO.java,v 1.52 2009-12-17 06:57:57 mchyzer Exp $

Constructor Summary

Constructors
Constructor and Description

Hib3MembershipDAO()

Constructors
Constructor and Description
`Hib3MembershipDAO()`

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`delete(Membership ms)` Delete a membership
`void`	`delete(Set<Membership> mships)` Delete a set of memberships
`Set<Membership>`	`findAll(boolean enabledOnly)` get all memberships
`Set<Membership>`	`findAllByAttrDefOwnerAndField(String ownerAttrDefId, Field f, boolean enabledOnly)`
`Set<Membership>`	`findAllByAttrDefOwnerAndFieldAndType(String ownerAttrDefId, Field f, String type, boolean enabledOnly)`
`Set<Membership>`	`findAllByAttrDefOwnerAndMember(String ownerAttrDefId, String memberUUID, boolean enabledOnly)`
`Set<Membership>`	`findAllByAttrDefOwnerAndMemberAndField(String ownerAttrDefId, String memberUUID, Field f, boolean enabledOnly)`
`List<Membership>`	`findAllByAttrDefOwnerAsList(String attrDefId, boolean enabledOnly)`
`Set<Object[]>`	findAllByAttributeDefOwnerOptions(Collection<String> attributeDefIds, Collection<String> memberIds, Collection<String> membershipIds, MembershipType membershipType, Collection<Field> fields, Set<Source> sources, String scope, Stem stem, Stem.Scope stemScope, Boolean enabled, Boolean shouldCheckSecurity, QueryOptions queryOptionsForAttributeDef, String scopeForAttributeDef, boolean splitScopeForAttributeDef, boolean hasFieldForAttributeDef, boolean hasMembershipTypeForAttributeDef) find memberships by stem owner and other options.
`Set<Object[]>`	findAllByAttributeDefOwnerOptions(Collection<String> attributeDefIds, Collection<String> memberIds, Collection<String> membershipIds, MembershipType membershipType, Collection<Field> fields, Set<Source> sources, String scope, Stem stem, Stem.Scope stemScope, Boolean enabled, Boolean shouldCheckSecurity, QueryOptions queryOptionsForMember, String filterForMember, boolean splitScopeForMember, boolean hasFieldForMember, boolean hasMembershipTypeForMember, QueryOptions queryOptionsForAttributeDef, String scopeForAttributeDef, boolean splitScopeForAttributeDef, boolean hasFieldForAttributeDef, boolean hasMembershipTypeForAttributeDef) find memberships by stem owner and other options.
`Set<Object[]>`	findAllByAttributeDefOwnerOptions(Collection<String> attributeDefIds, Collection<String> memberIds, Collection<String> membershipIds, MembershipType membershipType, Collection<Field> fields, Set<Source> sources, String scope, Stem stem, Stem.Scope stemScope, Boolean enabled, Boolean shouldCheckSecurity, QueryOptions queryOptionsForMember, String filterForMember, boolean splitScopeForMember, boolean hasFieldForMember, boolean hasMembershipTypeForMember, QueryOptions queryOptionsForAttributeDef, String scopeForAttributeDef, boolean splitScopeForAttributeDef, boolean hasFieldForAttributeDef, boolean hasMembershipTypeForAttributeDef, Boolean hasEnabledDate, Boolean hasDisabledDate, CompositeType customCompositeType, Group customCompositeGroup) find memberships by stem owner and other options.
`Set<Object[]>`	`findAllByAttributeDefOwnerOptions(Collection<String> totalAttributeDefIds, Collection<String> totalMemberIds, Collection<String> totalMembershipIds, MembershipType membershipType, Field field, Set<Source> sources, String scope, Stem stem, Stem.Scope stemScope, Boolean enabled, Boolean checkSecurity)` find memberships by stem owner and other options.
`Set<Object[]>`	`findAllByAttributeDefOwnerOptions(String attributeDefId, Collection<String> totalMemberIds, MembershipType membershipType, Collection<Field> fields, Set<Source> sources, Boolean enabled, QueryOptions queryOptions)` find membershpis by attribute def owner and other options.
`Set<Object[]>`	`findAllByAttributeDefOwnerOptions(String attributeDefId, MembershipType membershipType, Collection<Field> fields, Set<Source> sources, Boolean enabled, QueryOptions queryOptions)` find memberships by attribute def owner and other options.
`Set<Membership>`	`findAllByCreatedAfter(Date d, Field f, boolean enabledOnly)`
`Set<Membership>`	`findAllByCreatedBefore(Date d, Field f, boolean enabledOnly)`
`Set<Membership>`	`findAllByCreatorOrMember(Member member, boolean enabledOnly)` find all memberships that have this member or have this creator
`Set<Membership>`	`findAllByGroupOwnerAndCompositeAndMembers(String ownerGroupId, Collection<Member> members, boolean enabledOnly)`
`Set<Membership>`	`findAllByGroupOwnerAndDepth(String ownerGroupId, int depth, boolean enabledOnly)`
`Set<Membership>`	`findAllByGroupOwnerAndField(String ownerGroupId, Field f, boolean enabledOnly)`
`Set<Membership>`	`findAllByGroupOwnerAndFieldAndDepth(String ownerGroupId, Field f, int depth, boolean enabledOnly)`
`Set<Membership>`	`findAllByGroupOwnerAndFieldAndMemberIdsAndType(String ownerGroupId, Field f, Collection<String> memberIds, String type, boolean enabledOnly)`
`Set<Membership>`	`findAllByGroupOwnerAndFieldAndMembers(String ownerGroupId, Field f, Collection<Member> members, boolean enabledOnly)` TODO update for 1.5
`Set<Membership>`	`findAllByGroupOwnerAndFieldAndMembersAndType(String ownerGroupId, Field f, Collection<Member> members, String type, boolean enabledOnly)`
`Set<Membership>`	`findAllByGroupOwnerAndFieldAndType(String ownerGroupId, Field f, String type, boolean enabledOnly)`
`Set<Membership>`	`findAllByGroupOwnerAndMember(String ownerGroupId, String memberUUID, boolean enabledOnly)`
`Set<Membership>`	`findAllByGroupOwnerAndMemberAndField(String ownerGroupId, String memberUUID, Field f, boolean enabledOnly)`
`List<Membership>`	`findAllByGroupOwnerAsList(String ownerGroupId, boolean enabledOnly)`
`Set<Object[]>`	findAllByGroupOwnerOptions(Collection<String> totalGroupIds, Collection<String> totalMemberIds, Collection<String> totalMembershipIds, MembershipType membershipType, Collection<Field> fields, Collection<Privilege> privilegesTheUserHas, Set<Source> sources, String scope, Stem stem, Stem.Scope stemScope, Boolean enabled, Boolean checkSecurity, FieldType fieldType, String serviceId, ServiceRole serviceRole, QueryOptions queryOptionsForMember, String filterForMember, boolean splitScopeForMember, boolean hasFieldForMember, boolean hasMembershipTypeForMember, QueryOptions queryOptionsForGroup, String scopeForGroup, boolean splitScopeForGroup, boolean hasFieldForGroup, boolean hasMembershipTypeForGroup, Member memberHasMembershipForGroup) find memberships by group owner and other options.
`Set<Object[]>`	findAllByGroupOwnerOptions(Collection<String> totalGroupIds, Collection<String> totalMemberIds, Collection<String> totalMembershipIds, MembershipType membershipType, Collection<Field> fields, Collection<Privilege> privilegesTheUserHas, Set<Source> sources, String scope, Stem stem, Stem.Scope stemScope, Boolean enabled, Boolean checkSecurity, FieldType fieldType, String serviceId, ServiceRole serviceRole, QueryOptions queryOptionsForMember, String filterForMember, boolean splitScopeForMember, boolean hasFieldForMember, boolean hasMembershipTypeForMember, QueryOptions queryOptionsForGroup, String scopeForGroup, boolean splitScopeForGroup, boolean hasFieldForGroup, boolean hasMembershipTypeForGroup, Member memberHasMembershipForGroup, Boolean hasEnabledDate, Boolean hasDisabledDate, CompositeType customCompositeType, Group customCompositeGroup) find memberships by group owner and other options.
`Set<Object[]>`	findAllByGroupOwnerOptions(Collection<String> totalGroupIds, Collection<String> totalMemberIds, Collection<String> totalMembershipIds, MembershipType membershipType, Collection<Field> fields, Collection<Privilege> privilegesTheUserHas, Set<Source> sources, String scope, Stem stem, Stem.Scope stemScope, Boolean enabled, Boolean checkSecurity, FieldType fieldType, String serviceId, ServiceRole serviceRole, QueryOptions queryOptionsForMember, String filterForMember, boolean splitScopeForMember, boolean hasFieldForMember, boolean hasMembershipTypeForMember, QueryOptions queryOptionsForGroup, String scopeForGroup, boolean splitScopeForGroup, boolean hasFieldForGroup, boolean hasMembershipTypeForGroup, Member memberHasMembershipForGroup, Boolean hasEnabledDate, Boolean hasDisabledDate, CompositeType customCompositeType, Group customCompositeGroup, QueryOptions queryOptionsForMembership) find memberships by group owner and other options.
`Set<Object[]>`	`findAllByGroupOwnerOptions(Collection<String> totalGroupIds, Collection<String> totalMemberIds, Collection<String> totalMembershipIds, MembershipType membershipType, Field field, Set<Source> sources, String scope, Stem stem, Stem.Scope stemScope, Boolean enabled)` find membershpis by group owner and other options.
`Set<Object[]>`	`findAllByGroupOwnerOptions(Collection<String> totalGroupIds, Collection<String> totalMemberIds, Collection<String> totalMembershipIds, MembershipType membershipType, Field field, Set<Source> sources, String scope, Stem stem, Stem.Scope stemScope, Boolean enabled, Boolean checkSecurity)` find membershpis by group owner and other options.
`Set<Object[]>`	`findAllByGroupOwnerOptions(Collection<String> totalGroupIds, Collection<String> totalMemberIds, Collection<String> totalMembershipIds, MembershipType membershipType, Field field, Set<Source> sources, String scope, Stem stem, Stem.Scope stemScope, Boolean enabled, Boolean checkSecurity, FieldType fieldType)` find membershpis by group owner and other options.
`Set<Object[]>`	`findAllByGroupOwnerOptions(String groupId, Collection<String> totalMemberIds, MembershipType membershipType, Collection<Field> fields, Set<Source> sources, Boolean enabled, QueryOptions queryOptions)` find membershpis by group owner and other options.
`Set<Object[]>`	`findAllByGroupOwnerOptions(String groupId, MembershipType membershipType, Collection<Field> fields, Set<Source> sources, Boolean enabled, QueryOptions queryOptions)` find memberships by group owner and other options.
`Set<Membership>`	`findAllByMember(String memberUUID, boolean enabledOnly)`
`Set<Membership>`	`findAllByMemberAndDepth(String memberId, int depth, boolean enabledOnly)` (non-Javadoc)
`Set<Membership>`	`findAllByStemOwnerAndField(String ownerStemId, Field f, boolean enabledOnly)`
`Set<Membership>`	`findAllByStemOwnerAndFieldAndType(String ownerStemId, Field f, String type, boolean enabledOnly)`
`Set<Membership>`	`findAllByStemOwnerAndMemberAndField(String ownerStemId, String memberUUID, Field f, boolean enabledOnly)`
`List<Membership>`	`findAllByStemOwnerAsList(String ownerStemId, boolean enabledOnly)`
`Set<Object[]>`	findAllByStemOwnerOptions(Collection<String> totalStemIds, Collection<String> totalMemberIds, Collection<String> totalMembershipIds, MembershipType membershipType, Collection<Field> fields, Set<Source> sources, String scope, Stem stem, Stem.Scope stemScope, Boolean enabled, Boolean checkSecurity, QueryOptions queryOptionsForMember, String filterForMember, boolean splitScopeForMember, boolean hasFieldForMember, boolean hasMembershipTypeForMember, QueryOptions queryOptionsForStem, String scopeForStem, boolean splitScopeForStem, boolean hasFieldForStem, boolean hasMembershipTypeForStem) find memberships by stem owner and other options.
`Set<Object[]>`	findAllByStemOwnerOptions(Collection<String> totalStemIds, Collection<String> totalMemberIds, Collection<String> totalMembershipIds, MembershipType membershipType, Collection<Field> fields, Set<Source> sources, String scope, Stem stem, Stem.Scope stemScope, Boolean enabled, Boolean checkSecurity, QueryOptions queryOptionsForMember, String filterForMember, boolean splitScopeForMember, boolean hasFieldForMember, boolean hasMembershipTypeForMember, QueryOptions queryOptionsForStem, String scopeForStem, boolean splitScopeForStem, boolean hasFieldForStem, boolean hasMembershipTypeForStem, Boolean hasEnabledDate, Boolean hasDisabledDate, CompositeType customCompositeType, Group customCompositeGroup) find memberships by stem owner and other options.
`Set<Object[]>`	`findAllByStemOwnerOptions(Collection<String> totalStemIds, Collection<String> totalMemberIds, Collection<String> totalMembershipIds, MembershipType membershipType, Field field, Set<Source> sources, String scope, Stem stem, Stem.Scope stemScope, Boolean enabled, Boolean checkSecurity)` find memberships by stem owner and other options.
`Set<Membership>`	`findAllByStemParentOfGroupOwnerAndFieldAndType(Stem stem, Stem.Scope stemScope, Field field, MembershipType membershipType, Boolean enabledOnly, String memberId)`
`Set<Membership>`	`findAllChildMemberships(Membership _ms, boolean enabledOnly)`
`Set<Membership>`	`findAllEffectiveByAttrDefOwner(String ownerAttrDefId, String memberUUID, Field f, String viaGroupId, int depth, boolean enabledOnly)`
`Set<Membership>`	`findAllEffectiveByGroupOwner(String ownerGroupId, String memberUUID, Field f, String viaGroupId, int depth, boolean enabledOnly)`
`Set<Membership>`	`findAllEffectiveByGroupOwnerAndMemberAndField(String ownerGroupId, String memberUUID, Field f, boolean enabledOnly)`
`Set<Membership>`	`findAllEffectiveByMemberAndField(String memberUUID, Field f, boolean enabledOnly)`
`Set<Membership>`	`findAllEffectiveByStemOwner(String ownerStemId, String memberUUID, Field f, String viaGroupId, int depth, boolean enabledOnly)`
`Set<Membership>`	`findAllEnabledDisabledMismatch()` find records which are disabled which shouldnt be, and enabled which shouldnt be
`List<Membership>`	`findAllImmediateByAttrDefOwnerAsList(String attrDefId, boolean enabledOnly)`
`Set<Membership>`	`findAllImmediateByMember(String memberUUID, boolean enabledOnly)`
`Set<Membership>`	`findAllImmediateByMemberAndField(String memberUUID, Field f, boolean enabledOnly)`
`Set<Membership>`	`findAllImmediateByMemberAndFieldType(String memberUUID, String fieldType, boolean enabledOnly)`
`Set<Member>`	`findAllMembersByAttrDefOwnerAndFieldAndType(String ownerAttrDefId, Field f, String type, QueryOptions queryOptions, boolean enabledOnly)`
`List<Member>`	`findAllMembersByAttributeDefOwnerOptions(String attributeDefId, MembershipType membershipType, Collection<Field> fields, Set<Source> sources, Boolean enabled, QueryOptions queryOptions)` generally you will order by m.subjectSourceIdDb, m.subjectIdDb, and page to the first 100
`Set<Member>`	`findAllMembersByGroupOwnerAndField(String groupOwnerId, Field f, boolean enabledOnly)`
`Set<Member>`	`findAllMembersByGroupOwnerAndField(String groupOwnerId, Field f, QueryOptions queryOptions, boolean enabledOnly)`
`Set<Member>`	`findAllMembersByGroupOwnerAndField(String groupOwnerId, Field f, Set<Source> sources, QueryOptions queryOptions, boolean enabledOnly)`
`Set<Member>`	`findAllMembersByGroupOwnerAndFieldAndType(String ownerGroupId, Field f, String type, QueryOptions queryOptions, boolean enabledOnly)`
`Set<Member>`	`findAllMembersByGroupOwnerAndFieldAndType(String ownerGroupId, Field f, String type, Set<Source> sources, QueryOptions queryOptions, boolean enabledOnly)`
`List<Member>`	`findAllMembersByGroupOwnerOptions(String groupId, MembershipType membershipType, Collection<Field> fields, Set<Source> sources, Boolean enabled, QueryOptions queryOptions)` generally you will order by m.subjectSourceIdDb, m.subjectIdDb, and page to the first 100
`Set<Member>`	`findAllMembersByOwnerAndFieldAndType(String ownerId, Field f, String type, Set<Source> sources, QueryOptions queryOptions, boolean enabledOnly, SortStringEnum memberSortStringEnum, SearchStringEnum memberSearchStringEnum, String memberSearchStringValue)`
`Set<Member>`	`findAllMembersByStemOwnerAndFieldAndType(String ownerStemId, Field f, String type, QueryOptions queryOptions, boolean enabledOnly)` note, dont change this signature, Arnaud is using it
`Set<Membership>`	`findAllMembershipEntriesByGroupOwnerAndFieldAndType(String ownerGroupId, Field f, String type, boolean enabledOnly)` In this case, membership objects are not joined with groupSets like most queries.
`Set<Membership>`	`findAllMembershipsByGroupOwnerFieldDisabledRange(String ownerGroupId, Field f, Timestamp disabledDateFrom, Timestamp disabledDateTo)` Find all memberships based on group, field, and a range of disabled dates
`Set<Member>`	`findAllMembersInOneGroupNotOtherAndType(String ownerInGroupId, String ownerNotInGroupId, String typeIn, String typeNotIn, QueryOptions queryOptions, Boolean enabled, boolean disabledOwnerNull)`
`Set<Member>`	`findAllMembersInOneGroupNotStem(String ownerInGroupId, Stem ownerNotInStem, Stem.Scope stemScope, String typeIn, QueryOptions queryOptions)` find members in a group who are not members in any group under a stem
`Set<Membership>`	`findAllNonImmediateByMember(String memberUUID, boolean enabledOnly)`
`Set<Membership>`	`findAllNonImmediateByMemberAndField(String memberUUID, Field f, boolean enabledOnly)`
`Set<Membership>`	`findAllNonImmediateByMemberAndFieldType(String memberUUID, String fieldType, boolean enabledOnly)`
`Set<Membership>`	`findBadComplementMemberships()`
`Set<Membership>`	`findBadCompositeMembershipsOnNonCompositeGroup()`
`Set<Membership>`	`findBadIntersectionMemberships()`
`Set<Membership>`	`findBadMembershipsDeletedGroupAsMember()` Find cases where a membership exists where the member is a deleted group.
`Set<Membership>`	`findBadMembershipsOnCompositeGroup()` This will find "immediate" memberships on composite groups along with memberships that don't have the right viaCompositeId.
`Set<Membership>`	`findBadUnionMemberships()`
`Membership`	`findByAttrDefOwnerAndMemberAndFieldAndType(String ownerAttrDefId, String memberUUID, Field f, String type, boolean exceptionIfNull, boolean enabledOnly)`
`Membership`	`findByGroupOwnerAndMemberAndFieldAndType(String ownerGroupId, String memberUUID, Field f, String type, boolean exceptionIfNull, boolean enabledOnly)`
`Membership`	`findByImmediateUuid(String uuid, boolean exceptionIfNull)`
`Membership`	`findByImmediateUuid(String uuid, boolean exceptionIfNull, QueryOptions queryOptions)`
`Membership`	`findByImmediateUuidOrKey(String uuid, String memberUUID, String fieldId, String ownerAttrDefId, String ownerGroupId, String ownerStemId, boolean exceptionIfNull)`
`Membership`	`findByStemOwnerAndMemberAndFieldAndType(String ownerStemId, String memberUUID, Field f, String type, boolean exceptionIfNull, boolean enabledOnly)`
`Membership`	`findByUuid(String uuid, boolean exceptionIfNull, boolean enabledOnly)`
`Membership`	`findByUuid(String uuid, boolean exceptionIfNull, boolean enabledOnly, QueryOptions queryOptions)`
`Set<Membership>`	`findMembershipsByMemberAndFieldSecure(GrouperSession grouperSession, String memberUUID, Field f, boolean enabledOnly)` find memberships that the user is allowed to see
`Set<Object[]>`	`findMissingComplementMemberships()`
`Set<Membership>`	`findMissingImmediateGroupSetsForAttrDefOwners()` Find all missing group sets for immediate memberships where the owner is an attr def.
`Set<Membership>`	`findMissingImmediateGroupSetsForGroupOwners()` Find all missing group sets for immediate memberships where the owner is a group.
`Set<Membership>`	`findMissingImmediateGroupSetsForStemOwners()` Find all missing group sets for immediate memberships where the owner is a stem.
`Set<Object[]>`	`findMissingIntersectionMemberships()`
`Set<Object[]>`	`findMissingUnionMemberships()`
`Membership`	`findParentMembership(Membership _ms)`
`Set<String>`	`findSourceIdsByGroupOwnerOptions(String groupId, MembershipType membershipType, Field field, Boolean enabled)` find membershpis by group owner and other options.
`protected static void`	`reset(HibernateSession hibernateSession)`
`void`	`save(Membership ms)` Save a membership
`void`	`save(Set<Membership> mships)` Save a set of memberships
`void`	`saveUpdateProperties(Membership membership)` save the update properties which are auto saved when business method is called
`void`	`update(Membership ms)` Update a membership
`void`	`update(Set<Membership> mships)` Update a set of memberships

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
- Hib3MembershipDAO
```
public Hib3MembershipDAO()
```

Method Detail

findAll
```
public Set<Membership> findAll(boolean enabledOnly)
```
get all memberships

Specified by:

findAll in interface MembershipDAO

Parameters:

enabledOnly -

Returns:

set

findAllByCreatorOrMember
```
public Set<Membership> findAllByCreatorOrMember(Member member,
                                                boolean enabledOnly)
```
find all memberships that have this member or have this creator

Specified by:

findAllByCreatorOrMember in interface MembershipDAO

Parameters:

member -

enabledOnly -

Returns:

the memberships

findAllByCreatedAfter

public Set<Membership> findAllByCreatedAfter(Date d,
                                             Field f,
                                             boolean enabledOnly)
                                      throws GrouperDAOException

Specified by:: findAllByCreatedAfter in interface MembershipDAO
Parameters:: d -; f -; enabledOnly -
Returns:: set
Throws:: GrouperDAOException
Since:: @HEAD@

findAllByCreatedBefore

public Set<Membership> findAllByCreatedBefore(Date d,
                                              Field f,
                                              boolean enabledOnly)
                                       throws GrouperDAOException

Specified by:: findAllByCreatedBefore in interface MembershipDAO
Parameters:: d -; f -; enabledOnly -
Returns:: set
Throws:: GrouperDAOException
Since:: @HEAD@

findAllByMember

public Set<Membership> findAllByMember(String memberUUID,
                                       boolean enabledOnly)
                                throws GrouperDAOException

Specified by:: findAllByMember in interface MembershipDAO
Parameters:: memberUUID -; enabledOnly -
Returns:: set
Throws:: GrouperDAOException
Since:: @HEAD@

findAllByGroupOwnerAndField

public Set<Membership> findAllByGroupOwnerAndField(String ownerGroupId,
                                                   Field f,
                                                   boolean enabledOnly)
                                            throws GrouperDAOException

Specified by:: findAllByGroupOwnerAndField in interface MembershipDAO
Parameters:: ownerGroupId -; f -; enabledOnly -
Returns:: set
Throws:: GrouperDAOException
Since:: @HEAD@

findAllByStemOwnerAndField

public Set<Membership> findAllByStemOwnerAndField(String ownerStemId,
                                                  Field f,
                                                  boolean enabledOnly)
                                           throws GrouperDAOException

Specified by:: findAllByStemOwnerAndField in interface MembershipDAO
Parameters:: ownerStemId -; f -; enabledOnly -
Returns:: set
Throws:: GrouperDAOException
Since:: @HEAD@

findAllByStemOwnerAndFieldAndType

public Set<Membership> findAllByStemOwnerAndFieldAndType(String ownerStemId,
                                                         Field f,
                                                         String type,
                                                         boolean enabledOnly)
                                                  throws GrouperDAOException

Specified by:: findAllByStemOwnerAndFieldAndType in interface MembershipDAO
Parameters:: ownerStemId -; f -; type -; enabledOnly -
Returns:: set
Throws:: GrouperDAOException
Since:: @HEAD@

findAllByGroupOwnerAndFieldAndType

public Set<Membership> findAllByGroupOwnerAndFieldAndType(String ownerGroupId,
                                                          Field f,
                                                          String type,
                                                          boolean enabledOnly)
                                                   throws GrouperDAOException

Specified by:: findAllByGroupOwnerAndFieldAndType in interface MembershipDAO
Parameters:: ownerGroupId -; f -; type -; enabledOnly -
Returns:: set
Throws:: GrouperDAOException
Since:: @HEAD@

findAllByGroupOwnerAndFieldAndDepth

public Set<Membership> findAllByGroupOwnerAndFieldAndDepth(String ownerGroupId,
                                                           Field f,
                                                           int depth,
                                                           boolean enabledOnly)

Specified by:: findAllByGroupOwnerAndFieldAndDepth in interface MembershipDAO
Returns:: set
See Also:: MembershipDAO.findAllByGroupOwnerAndFieldAndDepth(java.lang.String, edu.internet2.middleware.grouper.Field, int, boolean)

findAllByGroupOwnerAndDepth

public Set<Membership> findAllByGroupOwnerAndDepth(String ownerGroupId,
                                                   int depth,
                                                   boolean enabledOnly)

Specified by:: findAllByGroupOwnerAndDepth in interface MembershipDAO
Returns:: set
See Also:: MembershipDAO.findAllByGroupOwnerAndDepth(java.lang.String, int, boolean)

findAllByMemberAndDepth

public Set<Membership> findAllByMemberAndDepth(String memberId,
                                               int depth,
                                               boolean enabledOnly)

(non-Javadoc)

Specified by:: findAllByMemberAndDepth in interface MembershipDAO
Returns:: set
See Also:: MembershipDAO.findAllByMemberAndDepth(java.lang.String, int, boolean)

findAllByStemOwnerAndMemberAndField

public Set<Membership> findAllByStemOwnerAndMemberAndField(String ownerStemId,
                                                           String memberUUID,
                                                           Field f,
                                                           boolean enabledOnly)
                                                    throws GrouperDAOException

Specified by:: findAllByStemOwnerAndMemberAndField in interface MembershipDAO
Parameters:: ownerStemId -; memberUUID -; f -; enabledOnly -
Returns:: set
Throws:: GrouperDAOException
Since:: @HEAD@

findAllByGroupOwnerAndMemberAndField

public Set<Membership> findAllByGroupOwnerAndMemberAndField(String ownerGroupId,
                                                            String memberUUID,
                                                            Field f,
                                                            boolean enabledOnly)
                                                     throws GrouperDAOException

Specified by:: findAllByGroupOwnerAndMemberAndField in interface MembershipDAO
Parameters:: ownerGroupId -; memberUUID -; f -; enabledOnly -
Returns:: set
Throws:: GrouperDAOException
Since:: @HEAD@

findAllMembersByGroupOwnerAndField

public Set<Member> findAllMembersByGroupOwnerAndField(String groupOwnerId,
                                                      Field f,
                                                      boolean enabledOnly)
                                               throws GrouperDAOException

Specified by:: findAllMembersByGroupOwnerAndField in interface MembershipDAO
Returns:: Members from memberships.
Throws:: GrouperDAOException - if any DAO errors occur.
See Also:: MembershipDAO.findAllMembersByGroupOwnerAndField(java.lang.String, edu.internet2.middleware.grouper.Field, boolean)

findAllMembersByGroupOwnerAndField

public Set<Member> findAllMembersByGroupOwnerAndField(String groupOwnerId,
                                                      Field f,
                                                      Set<Source> sources,
                                                      QueryOptions queryOptions,
                                                      boolean enabledOnly)
                                               throws GrouperDAOException

Specified by:: findAllMembersByGroupOwnerAndField in interface MembershipDAO
Returns:: the members
Throws:: GrouperDAOException
See Also:: MembershipDAO.findAllMembersByGroupOwnerAndField(java.lang.String, edu.internet2.middleware.grouper.Field, Set, edu.internet2.middleware.grouper.internal.dao.QueryOptions, boolean)

findAllMembersByGroupOwnerAndField

public Set<Member> findAllMembersByGroupOwnerAndField(String groupOwnerId,
                                                      Field f,
                                                      QueryOptions queryOptions,
                                                      boolean enabledOnly)
                                               throws GrouperDAOException

Specified by:: findAllMembersByGroupOwnerAndField in interface MembershipDAO
Returns:: the members
Throws:: GrouperDAOException
See Also:: MembershipDAO.findAllMembersByGroupOwnerAndField(java.lang.String, edu.internet2.middleware.grouper.Field, edu.internet2.middleware.grouper.internal.dao.QueryOptions, boolean)

findAllMembersByGroupOwnerAndFieldAndType

public Set<Member> findAllMembersByGroupOwnerAndFieldAndType(String ownerGroupId,
                                                             Field f,
                                                             String type,
                                                             QueryOptions queryOptions,
                                                             boolean enabledOnly)

Specified by:: findAllMembersByGroupOwnerAndFieldAndType in interface MembershipDAO
Parameters:: ownerGroupId -; f -; type -; queryOptions -; enabledOnly -
Returns:: set
Throws:: GrouperDAOException
Since:: @HEAD@

findAllByGroupOwnerOptions

public Set<Object[]> findAllByGroupOwnerOptions(Collection<String> totalGroupIds,
                                                Collection<String> totalMemberIds,
                                                Collection<String> totalMembershipIds,
                                                MembershipType membershipType,
                                                Field field,
                                                Set<Source> sources,
                                                String scope,
                                                Stem stem,
                                                Stem.Scope stemScope,
                                                Boolean enabled)

Description copied from interface: MembershipDAO

find membershpis by group owner and other options.

Specified by:: findAllByGroupOwnerOptions in interface MembershipDAO
Parameters:: totalGroupIds - to limit memberships to; totalMemberIds - to limit memberships to; totalMembershipIds - to limit memberships to; membershipType - Immediate, NonImmediate, etc; field - if finding one field, list here, otherwise all list fields will be returned; sources - if limiting memberships of members in certain sources, list here; scope - sql like string which will have a % appended to it; stem - if looking in a certain stem; stemScope - if looking only in this stem, or all substems; enabled - null for all, true for enabled only, false for disabled only
Returns:: a set of membership, group, and member objects
See Also:: MembershipDAO.findAllByGroupOwnerOptions(java.util.Collection, java.util.Collection, java.util.Collection, edu.internet2.middleware.grouper.membership.MembershipType, edu.internet2.middleware.grouper.Field, Set, java.lang.String, edu.internet2.middleware.grouper.Stem, edu.internet2.middleware.grouper.Stem.Scope, java.lang.Boolean)

findAllByGroupOwnerOptions

public Set<Object[]> findAllByGroupOwnerOptions(Collection<String> totalGroupIds,
                                                Collection<String> totalMemberIds,
                                                Collection<String> totalMembershipIds,
                                                MembershipType membershipType,
                                                Field field,
                                                Set<Source> sources,
                                                String scope,
                                                Stem stem,
                                                Stem.Scope stemScope,
                                                Boolean enabled,
                                                Boolean checkSecurity)

Description copied from interface: MembershipDAO

find membershpis by group owner and other options.

Specified by:: findAllByGroupOwnerOptions in interface MembershipDAO
Parameters:: totalGroupIds - to limit memberships to; totalMemberIds - to limit memberships to; totalMembershipIds - to limit memberships to; membershipType - Immediate, NonImmediate, etc; field - if finding one field, list here, otherwise all list fields will be returned; sources - if limiting memberships of members in certain sources, list here; scope - sql like string which will have a % appended to it; stem - if looking in a certain stem; stemScope - if looking only in this stem, or all substems; enabled - null for all, true for enabled only, false for disabled only; checkSecurity - if we should check security, default to true
Returns:: a set of membership, group, and member objects
See Also:: MembershipDAO.findAllByGroupOwnerOptions(java.util.Collection, java.util.Collection, java.util.Collection, edu.internet2.middleware.grouper.membership.MembershipType, edu.internet2.middleware.grouper.Field, Set, java.lang.String, edu.internet2.middleware.grouper.Stem, edu.internet2.middleware.grouper.Stem.Scope, java.lang.Boolean, Boolean)

findAllByGroupOwnerOptions

public Set<Object[]> findAllByGroupOwnerOptions(Collection<String> totalGroupIds,
                                                Collection<String> totalMemberIds,
                                                Collection<String> totalMembershipIds,
                                                MembershipType membershipType,
                                                Field field,
                                                Set<Source> sources,
                                                String scope,
                                                Stem stem,
                                                Stem.Scope stemScope,
                                                Boolean enabled,
                                                Boolean checkSecurity,
                                                FieldType fieldType)

Description copied from interface: MembershipDAO

find membershpis by group owner and other options.

Specified by:: findAllByGroupOwnerOptions in interface MembershipDAO
Parameters:: totalGroupIds - to limit memberships to; totalMemberIds - to limit memberships to; totalMembershipIds - to limit memberships to; membershipType - Immediate, NonImmediate, etc; field - if finding one field, list here, otherwise all list fields will be returned; sources - if limiting memberships of members in certain sources, list here; scope - sql like string which will have a % appended to it; stem - if looking in a certain stem; stemScope - if looking only in this stem, or all substems; enabled - null for all, true for enabled only, false for disabled only; checkSecurity - if we should check security, default to true; fieldType - if we are checking access or list memberships
Returns:: a set of membership, group, and member objects
See Also:: edu.internet2.middleware.grouper.internal.dao.MembershipDAO#findAllByGroupOwnerOptions(java.util.Collection, java.util.Collection, java.util.Collection, edu.internet2.middleware.grouper.membership.MembershipType, edu.internet2.middleware.grouper.Field, Set, java.lang.String, edu.internet2.middleware.grouper.Stem, edu.internet2.middleware.grouper.Stem.Scope, java.lang.Boolean, Boolean, FieldType, String, ServiceRole)

findAllByGroupOwnerOptions

public Set<Object[]> findAllByGroupOwnerOptions(Collection<String> totalGroupIds,
                                                Collection<String> totalMemberIds,
                                                Collection<String> totalMembershipIds,
                                                MembershipType membershipType,
                                                Collection<Field> fields,
                                                Collection<Privilege> privilegesTheUserHas,
                                                Set<Source> sources,
                                                String scope,
                                                Stem stem,
                                                Stem.Scope stemScope,
                                                Boolean enabled,
                                                Boolean checkSecurity,
                                                FieldType fieldType,
                                                String serviceId,
                                                ServiceRole serviceRole,
                                                QueryOptions queryOptionsForMember,
                                                String filterForMember,
                                                boolean splitScopeForMember,
                                                boolean hasFieldForMember,
                                                boolean hasMembershipTypeForMember,
                                                QueryOptions queryOptionsForGroup,
                                                String scopeForGroup,
                                                boolean splitScopeForGroup,
                                                boolean hasFieldForGroup,
                                                boolean hasMembershipTypeForGroup,
                                                Member memberHasMembershipForGroup)

Description copied from interface: MembershipDAO

find memberships by group owner and other options.

Specified by:: findAllByGroupOwnerOptions in interface MembershipDAO
Parameters:: totalGroupIds - to limit memberships to; totalMemberIds - to limit memberships to; totalMembershipIds - to limit memberships to; membershipType - Immediate, NonImmediate, etc; fields - if finding one field, list here, otherwise all list fields will be returned; privilegesTheUserHas - check to make sure the user has these privileges on the records; sources - if limiting memberships of members in certain sources, list here; scope - sql like string which will have a % appended to it; stem - if looking in a certain stem; stemScope - if looking only in this stem, or all substems; enabled - null for all, true for enabled only, false for disabled only; checkSecurity - if we should check security, default to true; fieldType - field type of of memberships; queryOptionsForMember - query options for member. must include paging. if sorting then sort by member; filterForMember - if paging for member, then also filter for member; splitScopeForMember - if the scope for member has spaces in it, then split by whitespace, and find results that contain all of the scope strings; hasFieldForMember - return memberships where the member has this field, note, it will return all the memberships for those members; hasMembershipTypeForMember - return memberships where the member has this field, note, it will return all the memberships for those members; memberHasMembershipForGroup - makes sure this member has a membership in the group before returning any results
Returns:: a set of membership, group, and member objects
See Also:: MembershipDAO.findAllByGroupOwnerOptions(java.util.Collection, java.util.Collection, java.util.Collection, edu.internet2.middleware.grouper.membership.MembershipType, java.util.Collection, java.util.Collection, java.util.Set, java.lang.String, edu.internet2.middleware.grouper.Stem, edu.internet2.middleware.grouper.Stem.Scope, java.lang.Boolean, java.lang.Boolean, edu.internet2.middleware.grouper.FieldType, java.lang.String, edu.internet2.middleware.grouper.service.ServiceRole, edu.internet2.middleware.grouper.internal.dao.QueryOptions, java.lang.String, boolean, boolean, boolean, edu.internet2.middleware.grouper.internal.dao.QueryOptions, java.lang.String, boolean, boolean, boolean, edu.internet2.middleware.grouper.Member)

findAllByGroupOwnerOptions

public Set<Object[]> findAllByGroupOwnerOptions(Collection<String> totalGroupIds,
                                                Collection<String> totalMemberIds,
                                                Collection<String> totalMembershipIds,
                                                MembershipType membershipType,
                                                Collection<Field> fields,
                                                Collection<Privilege> privilegesTheUserHas,
                                                Set<Source> sources,
                                                String scope,
                                                Stem stem,
                                                Stem.Scope stemScope,
                                                Boolean enabled,
                                                Boolean checkSecurity,
                                                FieldType fieldType,
                                                String serviceId,
                                                ServiceRole serviceRole,
                                                QueryOptions queryOptionsForMember,
                                                String filterForMember,
                                                boolean splitScopeForMember,
                                                boolean hasFieldForMember,
                                                boolean hasMembershipTypeForMember,
                                                QueryOptions queryOptionsForGroup,
                                                String scopeForGroup,
                                                boolean splitScopeForGroup,
                                                boolean hasFieldForGroup,
                                                boolean hasMembershipTypeForGroup,
                                                Member memberHasMembershipForGroup,
                                                Boolean hasEnabledDate,
                                                Boolean hasDisabledDate,
                                                CompositeType customCompositeType,
                                                Group customCompositeGroup)

Description copied from interface: MembershipDAO

find memberships by group owner and other options.

Specified by:: findAllByGroupOwnerOptions in interface MembershipDAO
Parameters:: totalGroupIds - to limit memberships to; totalMemberIds - to limit memberships to; totalMembershipIds - to limit memberships to; membershipType - Immediate, NonImmediate, etc; fields - if finding one field, list here, otherwise all list fields will be returned; privilegesTheUserHas - check to make sure the user has these privileges on the records; sources - if limiting memberships of members in certain sources, list here; scope - sql like string which will have a % appended to it; stem - if looking in a certain stem; stemScope - if looking only in this stem, or all substems; enabled - null for all, true for enabled only, false for disabled only; checkSecurity - if we should check security, default to true; fieldType - field type of of memberships; queryOptionsForMember - query options for member. must include paging. if sorting then sort by member; filterForMember - if paging for member, then also filter for member; splitScopeForMember - if the scope for member has spaces in it, then split by whitespace, and find results that contain all of the scope strings; hasFieldForMember - return memberships where the member has this field, note, it will return all the memberships for those members; hasMembershipTypeForMember - return memberships where the member has this field, note, it will return all the memberships for those members; memberHasMembershipForGroup - makes sure this member has a membership in the group before returning any results
Returns:: a set of membership, group, and member objects
See Also:: edu.internet2.middleware.grouper.internal.dao.MembershipDAO#findAllByGroupOwnerOptions(java.util.Collection, java.util.Collection, java.util.Collection, edu.internet2.middleware.grouper.membership.MembershipType, java.util.Collection, java.util.Collection, java.util.Set, java.lang.String, edu.internet2.middleware.grouper.Stem, edu.internet2.middleware.grouper.Stem.Scope, java.lang.Boolean, java.lang.Boolean, edu.internet2.middleware.grouper.FieldType, java.lang.String, edu.internet2.middleware.grouper.service.ServiceRole, edu.internet2.middleware.grouper.internal.dao.QueryOptions, java.lang.String, boolean, boolean, boolean, edu.internet2.middleware.grouper.internal.dao.QueryOptions, java.lang.String, boolean, boolean, boolean, edu.internet2.middleware.grouper.Member, java.lang.Boolean, java.lang.Boolean)

findAllByGroupOwnerOptions

public Set<Object[]> findAllByGroupOwnerOptions(Collection<String> totalGroupIds,
                                                Collection<String> totalMemberIds,
                                                Collection<String> totalMembershipIds,
                                                MembershipType membershipType,
                                                Collection<Field> fields,
                                                Collection<Privilege> privilegesTheUserHas,
                                                Set<Source> sources,
                                                String scope,
                                                Stem stem,
                                                Stem.Scope stemScope,
                                                Boolean enabled,
                                                Boolean checkSecurity,
                                                FieldType fieldType,
                                                String serviceId,
                                                ServiceRole serviceRole,
                                                QueryOptions queryOptionsForMember,
                                                String filterForMember,
                                                boolean splitScopeForMember,
                                                boolean hasFieldForMember,
                                                boolean hasMembershipTypeForMember,
                                                QueryOptions queryOptionsForGroup,
                                                String scopeForGroup,
                                                boolean splitScopeForGroup,
                                                boolean hasFieldForGroup,
                                                boolean hasMembershipTypeForGroup,
                                                Member memberHasMembershipForGroup,
                                                Boolean hasEnabledDate,
                                                Boolean hasDisabledDate,
                                                CompositeType customCompositeType,
                                                Group customCompositeGroup,
                                                QueryOptions queryOptionsForMembership)

Description copied from interface: MembershipDAO

find memberships by group owner and other options.

Specified by:: findAllByGroupOwnerOptions in interface MembershipDAO
Parameters:: totalGroupIds - to limit memberships to; totalMemberIds - to limit memberships to; totalMembershipIds - to limit memberships to; membershipType - Immediate, NonImmediate, etc; fields - if finding one field, list here, otherwise all list fields will be returned; privilegesTheUserHas - check to make sure the user has these privileges on the records; sources - if limiting memberships of members in certain sources, list here; scope - sql like string which will have a % appended to it; stem - if looking in a certain stem; stemScope - if looking only in this stem, or all substems; enabled - null for all, true for enabled only, false for disabled only; checkSecurity - if we should check security, default to true; fieldType - field type of of memberships; queryOptionsForMember - query options for member. must include paging. if sorting then sort by member; filterForMember - if paging for member, then also filter for member; splitScopeForMember - if the scope for member has spaces in it, then split by whitespace, and find results that contain all of the scope strings; hasFieldForMember - return memberships where the member has this field, note, it will return all the memberships for those members; hasMembershipTypeForMember - return memberships where the member has this field, note, it will return all the memberships for those members; memberHasMembershipForGroup - makes sure this member has a membership in the group before returning any results
Returns:: a set of membership, group, and member objects
See Also:: edu.internet2.middleware.grouper.internal.dao.MembershipDAO#findAllByGroupOwnerOptions(java.util.Collection, java.util.Collection, java.util.Collection, edu.internet2.middleware.grouper.membership.MembershipType, java.util.Collection, java.util.Collection, java.util.Set, java.lang.String, edu.internet2.middleware.grouper.Stem, edu.internet2.middleware.grouper.Stem.Scope, java.lang.Boolean, java.lang.Boolean, edu.internet2.middleware.grouper.FieldType, java.lang.String, edu.internet2.middleware.grouper.service.ServiceRole, edu.internet2.middleware.grouper.internal.dao.QueryOptions, java.lang.String, boolean, boolean, boolean, edu.internet2.middleware.grouper.internal.dao.QueryOptions, java.lang.String, boolean, boolean, boolean, edu.internet2.middleware.grouper.Member, java.lang.Boolean, java.lang.Boolean)

findAllMembersByGroupOwnerAndFieldAndType

public Set<Member> findAllMembersByGroupOwnerAndFieldAndType(String ownerGroupId,
                                                             Field f,
                                                             String type,
                                                             Set<Source> sources,
                                                             QueryOptions queryOptions,
                                                             boolean enabledOnly)
                                                      throws GrouperDAOException

Specified by:: findAllMembersByGroupOwnerAndFieldAndType in interface MembershipDAO
Parameters:: ownerGroupId -; f -; type -; sources -; queryOptions -; enabledOnly -
Returns:: set
Throws:: GrouperDAOException
Since:: @HEAD@

findAllMembersByOwnerAndFieldAndType

public Set<Member> findAllMembersByOwnerAndFieldAndType(String ownerId,
                                                        Field f,
                                                        String type,
                                                        Set<Source> sources,
                                                        QueryOptions queryOptions,
                                                        boolean enabledOnly,
                                                        SortStringEnum memberSortStringEnum,
                                                        SearchStringEnum memberSearchStringEnum,
                                                        String memberSearchStringValue)
                                                 throws GrouperDAOException

Specified by:: findAllMembersByOwnerAndFieldAndType in interface MembershipDAO; memberSortStringEnum - How to sort results or null for no sorting unless specified by queryOptions; memberSearchStringEnum - Specify search string if searching for members in the group; memberSearchStringValue - Search string value.
Returns:: set
Throws:: GrouperDAOException
See Also:: MembershipDAO.findAllMembersByOwnerAndFieldAndType(java.lang.String, edu.internet2.middleware.grouper.Field, java.lang.String, java.util.Set, edu.internet2.middleware.grouper.internal.dao.QueryOptions, boolean, edu.internet2.middleware.grouper.member.SortStringEnum, edu.internet2.middleware.grouper.member.SearchStringEnum, java.lang.String)

findAllMembersByStemOwnerAndFieldAndType

public Set<Member> findAllMembersByStemOwnerAndFieldAndType(String ownerStemId,
                                                            Field f,
                                                            String type,
                                                            QueryOptions queryOptions,
                                                            boolean enabledOnly)
                                                     throws GrouperDAOException

note, dont change this signature, Arnaud is using it

Specified by:: findAllMembersByStemOwnerAndFieldAndType in interface MembershipDAO
Parameters:: ownerStemId -; f -; type -; queryOptions -; enabledOnly -
Returns:: set
Throws:: GrouperDAOException
Since:: @HEAD@

findAllByGroupOwnerAndFieldAndMembersAndType

public Set<Membership> findAllByGroupOwnerAndFieldAndMembersAndType(String ownerGroupId,
                                                                    Field f,
                                                                    Collection<Member> members,
                                                                    String type,
                                                                    boolean enabledOnly)
                                                             throws GrouperDAOException

Specified by:: findAllByGroupOwnerAndFieldAndMembersAndType in interface MembershipDAO
Returns:: set
Throws:: GrouperDAOException
See Also:: MembershipDAO.findAllByGroupOwnerAndFieldAndMembersAndType(java.lang.String, edu.internet2.middleware.grouper.Field, java.util.Collection, java.lang.String, boolean)

findAllByGroupOwnerAndFieldAndMemberIdsAndType

public Set<Membership> findAllByGroupOwnerAndFieldAndMemberIdsAndType(String ownerGroupId,
                                                                      Field f,
                                                                      Collection<String> memberIds,
                                                                      String type,
                                                                      boolean enabledOnly)
                                                               throws GrouperDAOException

Specified by:: findAllByGroupOwnerAndFieldAndMemberIdsAndType in interface MembershipDAO
Returns:: set
Throws:: GrouperDAOException
See Also:: MembershipDAO.findAllByGroupOwnerAndFieldAndMemberIdsAndType(java.lang.String, edu.internet2.middleware.grouper.Field, java.util.Collection, java.lang.String, boolean)

findAllByGroupOwnerAndFieldAndMembers

public Set<Membership> findAllByGroupOwnerAndFieldAndMembers(String ownerGroupId,
                                                             Field f,
                                                             Collection<Member> members,
                                                             boolean enabledOnly)
                                                      throws GrouperDAOException

Description copied from interface: MembershipDAO

TODO update for 1.5

Specified by:: findAllByGroupOwnerAndFieldAndMembers in interface MembershipDAO
Returns:: set
Throws:: GrouperDAOException
See Also:: MembershipDAO.findAllByGroupOwnerAndFieldAndMembers(java.lang.String, edu.internet2.middleware.grouper.Field, java.util.Collection, boolean)

findAllByGroupOwnerAndCompositeAndMembers

public Set<Membership> findAllByGroupOwnerAndCompositeAndMembers(String ownerGroupId,
                                                                 Collection<Member> members,
                                                                 boolean enabledOnly)
                                                          throws GrouperDAOException

Specified by:: findAllByGroupOwnerAndCompositeAndMembers in interface MembershipDAO
Returns:: set
Throws:: GrouperDAOException
See Also:: MembershipDAO.findAllByGroupOwnerAndCompositeAndMembers(java.lang.String, java.util.Collection, boolean)

findByGroupOwnerAndMemberAndFieldAndType

public Membership findByGroupOwnerAndMemberAndFieldAndType(String ownerGroupId,
                                                           String memberUUID,
                                                           Field f,
                                                           String type,
                                                           boolean exceptionIfNull,
                                                           boolean enabledOnly)
                                                    throws GrouperDAOException,
                                                           MembershipNotFoundException

Specified by:: findByGroupOwnerAndMemberAndFieldAndType in interface MembershipDAO
Returns:: membership
Throws:: GrouperDAOException; MembershipNotFoundException
See Also:: MembershipDAO.findByGroupOwnerAndMemberAndFieldAndType(java.lang.String, java.lang.String, edu.internet2.middleware.grouper.Field, java.lang.String, boolean, boolean)

findByStemOwnerAndMemberAndFieldAndType

public Membership findByStemOwnerAndMemberAndFieldAndType(String ownerStemId,
                                                          String memberUUID,
                                                          Field f,
                                                          String type,
                                                          boolean exceptionIfNull,
                                                          boolean enabledOnly)
                                                   throws GrouperDAOException,
                                                          MembershipNotFoundException

Specified by:: findByStemOwnerAndMemberAndFieldAndType in interface MembershipDAO
Returns:: membership
Throws:: GrouperDAOException; MembershipNotFoundException
See Also:: MembershipDAO.findByStemOwnerAndMemberAndFieldAndType(java.lang.String, java.lang.String, edu.internet2.middleware.grouper.Field, java.lang.String, boolean, boolean)

findAllChildMemberships

public Set<Membership> findAllChildMemberships(Membership _ms,
                                               boolean enabledOnly)
                                        throws GrouperDAOException

Specified by:: findAllChildMemberships in interface MembershipDAO
Parameters:: _ms -; enabledOnly -
Returns:: set
Throws:: GrouperDAOException
Since:: @HEAD@

findAllEffectiveByGroupOwner

public Set<Membership> findAllEffectiveByGroupOwner(String ownerGroupId,
                                                    String memberUUID,
                                                    Field f,
                                                    String viaGroupId,
                                                    int depth,
                                                    boolean enabledOnly)
                                             throws GrouperDAOException

Specified by:: findAllEffectiveByGroupOwner in interface MembershipDAO
Parameters:: ownerGroupId -; memberUUID -; f -; viaGroupId -; depth -; enabledOnly -
Returns:: set
Throws:: GrouperDAOException
Since:: @HEAD@

findAllEffectiveByStemOwner

public Set<Membership> findAllEffectiveByStemOwner(String ownerStemId,
                                                   String memberUUID,
                                                   Field f,
                                                   String viaGroupId,
                                                   int depth,
                                                   boolean enabledOnly)
                                            throws GrouperDAOException

Specified by:: findAllEffectiveByStemOwner in interface MembershipDAO
Parameters:: ownerStemId -; memberUUID -; f -; viaGroupId -; depth -; enabledOnly -
Returns:: set
Throws:: GrouperDAOException
Since:: @HEAD@

findAllEffectiveByMemberAndField

public Set<Membership> findAllEffectiveByMemberAndField(String memberUUID,
                                                        Field f,
                                                        boolean enabledOnly)
                                                 throws GrouperDAOException

Specified by:: findAllEffectiveByMemberAndField in interface MembershipDAO
Parameters:: memberUUID -; f -; enabledOnly -
Returns:: set
Throws:: GrouperDAOException
Since:: @HEAD@

findAllEffectiveByGroupOwnerAndMemberAndField

public Set<Membership> findAllEffectiveByGroupOwnerAndMemberAndField(String ownerGroupId,
                                                                     String memberUUID,
                                                                     Field f,
                                                                     boolean enabledOnly)
                                                              throws GrouperDAOException

Specified by:: findAllEffectiveByGroupOwnerAndMemberAndField in interface MembershipDAO
Parameters:: ownerGroupId -; memberUUID -; f -; enabledOnly -
Returns:: set
Throws:: GrouperDAOException
Since:: @HEAD@

findAllByGroupOwnerAndMember

public Set<Membership> findAllByGroupOwnerAndMember(String ownerGroupId,
                                                    String memberUUID,
                                                    boolean enabledOnly)
                                             throws GrouperDAOException

Specified by:: findAllByGroupOwnerAndMember in interface MembershipDAO
Parameters:: ownerGroupId -; memberUUID -; enabledOnly -
Returns:: set
Throws:: GrouperDAOException
Since:: 1.2.1

findAllImmediateByMember

public Set<Membership> findAllImmediateByMember(String memberUUID,
                                                boolean enabledOnly)
                                         throws GrouperDAOException

Specified by:: findAllImmediateByMember in interface MembershipDAO
Parameters:: memberUUID -; enabledOnly -
Returns:: set
Throws:: GrouperDAOException
Since:: @HEAD@

findAllByGroupOwnerAsList

public List<Membership> findAllByGroupOwnerAsList(String ownerGroupId,
                                                  boolean enabledOnly)
                                           throws GrouperDAOException

Specified by:: findAllByGroupOwnerAsList in interface MembershipDAO
Parameters:: ownerGroupId -; enabledOnly -
Returns:: list
Throws:: GrouperDAOException
Since:: @HEAD@

findAllByStemOwnerAsList

public List<Membership> findAllByStemOwnerAsList(String ownerStemId,
                                                 boolean enabledOnly)
                                          throws GrouperDAOException

Specified by:: findAllByStemOwnerAsList in interface MembershipDAO
Parameters:: ownerStemId -; enabledOnly -
Returns:: list
Throws:: GrouperDAOException
Since:: @HEAD@

findAllImmediateByMemberAndField

public Set<Membership> findAllImmediateByMemberAndField(String memberUUID,
                                                        Field f,
                                                        boolean enabledOnly)
                                                 throws GrouperDAOException

Specified by:: findAllImmediateByMemberAndField in interface MembershipDAO
Parameters:: memberUUID -; f -; enabledOnly -
Returns:: set
Throws:: GrouperDAOException
Since:: @HEAD@

findAllImmediateByMemberAndFieldType

public Set<Membership> findAllImmediateByMemberAndFieldType(String memberUUID,
                                                            String fieldType,
                                                            boolean enabledOnly)
                                                     throws GrouperDAOException

Specified by:: findAllImmediateByMemberAndFieldType in interface MembershipDAO
Parameters:: memberUUID -; fieldType -; enabledOnly -
Returns:: set
Throws:: GrouperDAOException
Since:: @HEAD@

findByUuid

public Membership findByUuid(String uuid,
                             boolean exceptionIfNull,
                             boolean enabledOnly)
                      throws GrouperDAOException,
                             MembershipNotFoundException

Specified by:: findByUuid in interface MembershipDAO
Parameters:: uuid -; exceptionIfNull -; enabledOnly -
Returns:: membership
Throws:: GrouperDAOException; MembershipNotFoundException

findByUuid

public Membership findByUuid(String uuid,
                             boolean exceptionIfNull,
                             boolean enabledOnly,
                             QueryOptions queryOptions)
                      throws GrouperDAOException,
                             MembershipNotFoundException

Specified by:: findByUuid in interface MembershipDAO
Parameters:: uuid -; exceptionIfNull -; enabledOnly -; queryOptions -
Returns:: membership
Throws:: GrouperDAOException; MembershipNotFoundException

findMembershipsByMemberAndFieldSecure

public Set<Membership> findMembershipsByMemberAndFieldSecure(GrouperSession grouperSession,
                                                             String memberUUID,
                                                             Field f,
                                                             boolean enabledOnly)
                                                      throws GrouperDAOException

Description copied from interface: MembershipDAO

find memberships that the user is allowed to see

Specified by:: findMembershipsByMemberAndFieldSecure in interface MembershipDAO
Returns:: the memberships
Throws:: GrouperDAOException
See Also:: MembershipDAO.findMembershipsByMemberAndFieldSecure(edu.internet2.middleware.grouper.GrouperSession, java.lang.String, edu.internet2.middleware.grouper.Field, boolean)

save
```
public void save(Membership ms)
```
Description copied from interface: MembershipDAO

Save a membership

Specified by:

save in interface MembershipDAO

See Also:

MembershipDAO.save(edu.internet2.middleware.grouper.Membership)

save
```
public void save(Set<Membership> mships)
```
Description copied from interface: MembershipDAO

Save a set of memberships

Specified by:

save in interface MembershipDAO

See Also:

MembershipDAO.save(java.util.Set)

delete
```
public void delete(Membership ms)
```
Description copied from interface: MembershipDAO

Delete a membership

Specified by:

delete in interface MembershipDAO

See Also:

MembershipDAO.delete(edu.internet2.middleware.grouper.Membership)

update
```
public void update(Membership ms)
```
Description copied from interface: MembershipDAO

Update a membership

Specified by:

update in interface MembershipDAO

See Also:

MembershipDAO.update(edu.internet2.middleware.grouper.Membership)

delete
```
public void delete(Set<Membership> mships)
```
Description copied from interface: MembershipDAO

Delete a set of memberships

Specified by:

delete in interface MembershipDAO

See Also:

MembershipDAO.delete(java.util.Set)

update
```
public void update(Set<Membership> mships)
```
Description copied from interface: MembershipDAO

Update a set of memberships

Specified by:

update in interface MembershipDAO

See Also:

MembershipDAO.update(java.util.Set)

reset

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

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

findParentMembership
```
public Membership findParentMembership(Membership _ms)
                                throws GrouperDAOException
```
Specified by:

findParentMembership in interface MembershipDAO

Returns:

membership

Throws:

GrouperDAOException

See Also:

MembershipDAO.findParentMembership(edu.internet2.middleware.grouper.Membership)

findMissingImmediateGroupSetsForGroupOwners
```
public Set<Membership> findMissingImmediateGroupSetsForGroupOwners()
```
Description copied from interface: MembershipDAO

Find all missing group sets for immediate memberships where the owner is a group.

Specified by:

findMissingImmediateGroupSetsForGroupOwners in interface MembershipDAO

Returns:

set of memberships for which a groupSet is missing

See Also:

MembershipDAO.findMissingImmediateGroupSetsForGroupOwners()

findMissingImmediateGroupSetsForStemOwners
```
public Set<Membership> findMissingImmediateGroupSetsForStemOwners()
```
Description copied from interface: MembershipDAO

Find all missing group sets for immediate memberships where the owner is a stem.

Specified by:

findMissingImmediateGroupSetsForStemOwners in interface MembershipDAO

Returns:

set of memberships for which a groupSet is missing

See Also:

MembershipDAO.findMissingImmediateGroupSetsForStemOwners()

findByAttrDefOwnerAndMemberAndFieldAndType

public Membership findByAttrDefOwnerAndMemberAndFieldAndType(String ownerAttrDefId,
                                                             String memberUUID,
                                                             Field f,
                                                             String type,
                                                             boolean exceptionIfNull,
                                                             boolean enabledOnly)
                                                      throws GrouperDAOException,
                                                             MembershipNotFoundException

Specified by:: findByAttrDefOwnerAndMemberAndFieldAndType in interface MembershipDAO
Returns:: membership
Throws:: GrouperDAOException; MembershipNotFoundException
See Also:: MembershipDAO.findByAttrDefOwnerAndMemberAndFieldAndType(java.lang.String, java.lang.String, edu.internet2.middleware.grouper.Field, java.lang.String, boolean, boolean)

findAllEffectiveByAttrDefOwner

public Set<Membership> findAllEffectiveByAttrDefOwner(String ownerAttrDefId,
                                                      String memberUUID,
                                                      Field f,
                                                      String viaGroupId,
                                                      int depth,
                                                      boolean enabledOnly)
                                               throws GrouperDAOException

Specified by:: findAllEffectiveByAttrDefOwner in interface MembershipDAO
Returns:: set
Throws:: GrouperDAOException
See Also:: MembershipDAO.findAllEffectiveByAttrDefOwner(java.lang.String, java.lang.String, edu.internet2.middleware.grouper.Field, java.lang.String, int, boolean)

findAllMembersByAttrDefOwnerAndFieldAndType

public Set<Member> findAllMembersByAttrDefOwnerAndFieldAndType(String ownerAttrDefId,
                                                               Field f,
                                                               String type,
                                                               QueryOptions queryOptions,
                                                               boolean enabledOnly)
                                                        throws GrouperDAOException

Specified by:: findAllMembersByAttrDefOwnerAndFieldAndType in interface MembershipDAO
Returns:: set
Throws:: GrouperDAOException
See Also:: MembershipDAO.findAllMembersByAttrDefOwnerAndFieldAndType(java.lang.String, edu.internet2.middleware.grouper.Field, java.lang.String, edu.internet2.middleware.grouper.internal.dao.QueryOptions, boolean)

findMissingImmediateGroupSetsForAttrDefOwners
```
public Set<Membership> findMissingImmediateGroupSetsForAttrDefOwners()
```
Description copied from interface: MembershipDAO

Find all missing group sets for immediate memberships where the owner is an attr def.

Specified by:

findMissingImmediateGroupSetsForAttrDefOwners in interface MembershipDAO

Returns:

set of memberships for which a groupSet is missing

See Also:

MembershipDAO.findMissingImmediateGroupSetsForAttrDefOwners()

findAllByAttrDefOwnerAndField

public Set<Membership> findAllByAttrDefOwnerAndField(String ownerAttrDefId,
                                                     Field f,
                                                     boolean enabledOnly)
                                              throws GrouperDAOException

Specified by:: findAllByAttrDefOwnerAndField in interface MembershipDAO
Returns:: set
Throws:: GrouperDAOException
See Also:: MembershipDAO.findAllByAttrDefOwnerAndField(java.lang.String, edu.internet2.middleware.grouper.Field, boolean)

findAllByAttrDefOwnerAndFieldAndType

public Set<Membership> findAllByAttrDefOwnerAndFieldAndType(String ownerAttrDefId,
                                                            Field f,
                                                            String type,
                                                            boolean enabledOnly)
                                                     throws GrouperDAOException

Specified by:: findAllByAttrDefOwnerAndFieldAndType in interface MembershipDAO
Returns:: set
Throws:: GrouperDAOException
See Also:: MembershipDAO.findAllByAttrDefOwnerAndFieldAndType(java.lang.String, edu.internet2.middleware.grouper.Field, java.lang.String, boolean)

findAllByAttrDefOwnerAndMemberAndField

public Set<Membership> findAllByAttrDefOwnerAndMemberAndField(String ownerAttrDefId,
                                                              String memberUUID,
                                                              Field f,
                                                              boolean enabledOnly)
                                                       throws GrouperDAOException

Specified by:: findAllByAttrDefOwnerAndMemberAndField in interface MembershipDAO
Returns:: set
Throws:: GrouperDAOException
See Also:: MembershipDAO.findAllByAttrDefOwnerAndMemberAndField(java.lang.String, java.lang.String, edu.internet2.middleware.grouper.Field, boolean)

findAllByAttrDefOwnerAsList

public List<Membership> findAllByAttrDefOwnerAsList(String attrDefId,
                                                    boolean enabledOnly)
                                             throws GrouperDAOException

Specified by:: findAllByAttrDefOwnerAsList in interface MembershipDAO
Returns:: list
Throws:: GrouperDAOException
See Also:: MembershipDAO.findAllByAttrDefOwnerAsList(java.lang.String, boolean)

findAllImmediateByAttrDefOwnerAsList

public List<Membership> findAllImmediateByAttrDefOwnerAsList(String attrDefId,
                                                             boolean enabledOnly)
                                                      throws GrouperDAOException

Specified by:: findAllImmediateByAttrDefOwnerAsList in interface MembershipDAO
Returns:: list
Throws:: GrouperDAOException
See Also:: MembershipDAO.findAllImmediateByAttrDefOwnerAsList(java.lang.String, boolean)

findAllByAttrDefOwnerAndMember

public Set<Membership> findAllByAttrDefOwnerAndMember(String ownerAttrDefId,
                                                      String memberUUID,
                                                      boolean enabledOnly)
                                               throws GrouperDAOException

Specified by:: findAllByAttrDefOwnerAndMember in interface MembershipDAO
Returns:: set
Throws:: GrouperDAOException
See Also:: MembershipDAO.findAllByAttrDefOwnerAndMember(java.lang.String, java.lang.String, boolean)

findAllEnabledDisabledMismatch
```
public Set<Membership> findAllEnabledDisabledMismatch()
```
Description copied from interface: MembershipDAO

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

Specified by:

findAllEnabledDisabledMismatch in interface MembershipDAO

Returns:

the memberships

See Also:

MembershipDAO.findAllEnabledDisabledMismatch()

findAllNonImmediateByMember

public Set<Membership> findAllNonImmediateByMember(String memberUUID,
                                                   boolean enabledOnly)
                                            throws GrouperDAOException

Specified by:: findAllNonImmediateByMember in interface MembershipDAO
Returns:: set
Throws:: GrouperDAOException
See Also:: MembershipDAO.findAllNonImmediateByMember(java.lang.String, boolean)

findAllNonImmediateByMemberAndField

public Set<Membership> findAllNonImmediateByMemberAndField(String memberUUID,
                                                           Field f,
                                                           boolean enabledOnly)
                                                    throws GrouperDAOException

Specified by:: findAllNonImmediateByMemberAndField in interface MembershipDAO
Returns:: set
Throws:: GrouperDAOException
See Also:: MembershipDAO.findAllNonImmediateByMemberAndField(java.lang.String, edu.internet2.middleware.grouper.Field, boolean)

findAllNonImmediateByMemberAndFieldType

public Set<Membership> findAllNonImmediateByMemberAndFieldType(String memberUUID,
                                                               String fieldType,
                                                               boolean enabledOnly)
                                                        throws GrouperDAOException

Specified by:: findAllNonImmediateByMemberAndFieldType in interface MembershipDAO
Returns:: set
Throws:: GrouperDAOException
See Also:: MembershipDAO.findAllNonImmediateByMemberAndFieldType(java.lang.String, java.lang.String, boolean)

findByImmediateUuidOrKey

public Membership findByImmediateUuidOrKey(String uuid,
                                           String memberUUID,
                                           String fieldId,
                                           String ownerAttrDefId,
                                           String ownerGroupId,
                                           String ownerStemId,
                                           boolean exceptionIfNull)
                                    throws GrouperDAOException

Specified by:: findByImmediateUuidOrKey in interface MembershipDAO
Returns:: the stem or null
Throws:: GrouperDAOException
See Also:: MembershipDAO.findByImmediateUuidOrKey(java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, java.lang.String, boolean)

saveUpdateProperties
```
public void saveUpdateProperties(Membership membership)
```
Description copied from interface: MembershipDAO

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

Specified by:

saveUpdateProperties in interface MembershipDAO

See Also:

MembershipDAO.saveUpdateProperties(edu.internet2.middleware.grouper.Membership)

findSourceIdsByGroupOwnerOptions
```
public Set<String> findSourceIdsByGroupOwnerOptions(String groupId,
                                                    MembershipType membershipType,
                                                    Field field,
                                                    Boolean enabled)
```
Description copied from interface: MembershipDAO

find membershpis by group owner and other options.

Specified by:

findSourceIdsByGroupOwnerOptions in interface MembershipDAO

Parameters:

groupId - to limit memberships to

membershipType - Immediate, NonImmediate, etc

field - if finding one field, list here, otherwise members list is returned

enabled - null for all, true for enabled only, false for disabled only

Returns:

a set of sourceIds

See Also:

MembershipDAO.findSourceIdsByGroupOwnerOptions(java.lang.String, edu.internet2.middleware.grouper.membership.MembershipType, edu.internet2.middleware.grouper.Field, java.lang.Boolean)

findAllByStemParentOfGroupOwnerAndFieldAndType

public Set<Membership> findAllByStemParentOfGroupOwnerAndFieldAndType(Stem stem,
                                                                      Stem.Scope stemScope,
                                                                      Field field,
                                                                      MembershipType membershipType,
                                                                      Boolean enabledOnly,
                                                                      String memberId)
                                                               throws GrouperDAOException

Specified by:: findAllByStemParentOfGroupOwnerAndFieldAndType in interface MembershipDAO; membershipType - e.g. immediate
Returns:: set
Throws:: GrouperDAOException
See Also:: MembershipDAO#findAllByStemParentOfGroupOwnerAndFieldAndType(Stem, Scope, Field, MembershipType, Boolean, String)

findAllMembersInOneGroupNotOtherAndType

public Set<Member> findAllMembersInOneGroupNotOtherAndType(String ownerInGroupId,
                                                           String ownerNotInGroupId,
                                                           String typeIn,
                                                           String typeNotIn,
                                                           QueryOptions queryOptions,
                                                           Boolean enabled,
                                                           boolean disabledOwnerNull)
                                                    throws GrouperDAOException

Specified by:: findAllMembersInOneGroupNotOtherAndType in interface MembershipDAO; enabled - T for enabled, F for disabled, null for all; disabledOwnerNull - if true, the owner must have disabled date of null
Returns:: set
Throws:: GrouperDAOException
See Also:: MembershipDAO.findAllMembersInOneGroupNotOtherAndType(String, String, String, String, QueryOptions, Boolean, boolean)

findAllMembershipsByGroupOwnerFieldDisabledRange

public Set<Membership> findAllMembershipsByGroupOwnerFieldDisabledRange(String ownerGroupId,
                                                                        Field f,
                                                                        Timestamp disabledDateFrom,
                                                                        Timestamp disabledDateTo)

Description copied from interface: MembershipDAO

Find all memberships based on group, field, and a range of disabled dates

Specified by:: findAllMembershipsByGroupOwnerFieldDisabledRange in interface MembershipDAO
Parameters:: ownerGroupId - memberships in this owner; disabledDateFrom - null if dont consider; disabledDateTo - null if dont consider
Returns:: memberships.
See Also:: MembershipDAO.findAllMembershipsByGroupOwnerFieldDisabledRange(java.lang.String, edu.internet2.middleware.grouper.Field, java.sql.Timestamp, java.sql.Timestamp)

findAllMembersInOneGroupNotStem

public Set<Member> findAllMembersInOneGroupNotStem(String ownerInGroupId,
                                                   Stem ownerNotInStem,
                                                   Stem.Scope stemScope,
                                                   String typeIn,
                                                   QueryOptions queryOptions)

Description copied from interface: MembershipDAO

find members in a group who are not members in any group under a stem

Specified by:: findAllMembersInOneGroupNotStem in interface MembershipDAO
Returns:: set
See Also:: MembershipDAO#findAllMembersInOneGroupNotStem(String, Stem, Scope, String, QueryOptions)

findAllByAttributeDefOwnerOptions
```
public Set<Object[]> findAllByAttributeDefOwnerOptions(String attributeDefId,
                                                       MembershipType membershipType,
                                                       Collection<Field> fields,
                                                       Set<Source> sources,
                                                       Boolean enabled,
                                                       QueryOptions queryOptions)
```
Description copied from interface: MembershipDAO

find memberships by attribute def owner and other options.

Specified by:

findAllByAttributeDefOwnerOptions in interface MembershipDAO

Parameters:

attributeDefId - to limit memberships to

membershipType - Immediate, NonImmediate, etc

fields - if finding by fields, list here, otherwise all list fields will be returned

sources - if limiting memberships of members in certain sources, list here

enabled - null for all, true for enabled only, false for disabled only

queryOptions - for the query

Returns:

a set of membership and member objects

See Also:

MembershipDAO.findAllByAttributeDefOwnerOptions(java.lang.String, edu.internet2.middleware.grouper.membership.MembershipType, java.util.Collection, java.util.Set, java.lang.Boolean, edu.internet2.middleware.grouper.internal.dao.QueryOptions)

findAllByAttributeDefOwnerOptions
```
public Set<Object[]> findAllByAttributeDefOwnerOptions(String attributeDefId,
                                                       Collection<String> totalMemberIds,
                                                       MembershipType membershipType,
                                                       Collection<Field> fields,
                                                       Set<Source> sources,
                                                       Boolean enabled,
                                                       QueryOptions queryOptions)
```
Description copied from interface: MembershipDAO

find membershpis by attribute def owner and other options.

Specified by:

findAllByAttributeDefOwnerOptions in interface MembershipDAO

Parameters:

attributeDefId - to limit memberships to

totalMemberIds - memberids to get, or blank for all

membershipType - Immediate, NonImmediate, etc

fields - if finding by fields, list here, otherwise all list fields will be returned

sources - if limiting memberships of members in certain sources, list here

enabled - null for all, true for enabled only, false for disabled only

queryOptions - for the query

Returns:

a set of membership and member objects

See Also:

MembershipDAO.findAllByAttributeDefOwnerOptions(java.lang.String, java.util.Collection, edu.internet2.middleware.grouper.membership.MembershipType, java.util.Collection, java.util.Set, java.lang.Boolean, edu.internet2.middleware.grouper.internal.dao.QueryOptions)

findAllMembersByAttributeDefOwnerOptions
```
public List<Member> findAllMembersByAttributeDefOwnerOptions(String attributeDefId,
                                                             MembershipType membershipType,
                                                             Collection<Field> fields,
                                                             Set<Source> sources,
                                                             Boolean enabled,
                                                             QueryOptions queryOptions)
```
generally you will order by m.subjectSourceIdDb, m.subjectIdDb, and page to the first 100

Specified by:

findAllMembersByAttributeDefOwnerOptions in interface MembershipDAO

Parameters:

attributeDefId - to limit memberships to

membershipType - Immediate, NonImmediate, etc

fields - if finding by fields, list here, otherwise all list fields will be returned

sources - if limiting memberships of members in certain sources, list here

enabled - null for all, true for enabled only, false for disabled only

queryOptions - for the query

Returns:

a set of members and member objects

See Also:

MembershipDAO.findAllMembersByAttributeDefOwnerOptions(java.lang.String, edu.internet2.middleware.grouper.membership.MembershipType, java.util.Collection, java.util.Set, java.lang.Boolean, edu.internet2.middleware.grouper.internal.dao.QueryOptions)

findAllMembersByGroupOwnerOptions
```
public List<Member> findAllMembersByGroupOwnerOptions(String groupId,
                                                      MembershipType membershipType,
                                                      Collection<Field> fields,
                                                      Set<Source> sources,
                                                      Boolean enabled,
                                                      QueryOptions queryOptions)
```
generally you will order by m.subjectSourceIdDb, m.subjectIdDb, and page to the first 100

Specified by:

findAllMembersByGroupOwnerOptions in interface MembershipDAO

Parameters:

groupId - to limit memberships to

membershipType - Immediate, NonImmediate, etc

fields - if finding by fields, list here, otherwise all list fields will be returned

sources - if limiting memberships of members in certain sources, list here

enabled - null for all, true for enabled only, false for disabled only

queryOptions - for the query

Returns:

a set of members and member objects

See Also:

MembershipDAO.findAllMembersByGroupOwnerOptions(java.lang.String, edu.internet2.middleware.grouper.membership.MembershipType, java.util.Collection, java.util.Set, java.lang.Boolean, edu.internet2.middleware.grouper.internal.dao.QueryOptions)

findAllByGroupOwnerOptions
```
public Set<Object[]> findAllByGroupOwnerOptions(String groupId,
                                                Collection<String> totalMemberIds,
                                                MembershipType membershipType,
                                                Collection<Field> fields,
                                                Set<Source> sources,
                                                Boolean enabled,
                                                QueryOptions queryOptions)
```
Description copied from interface: MembershipDAO

find membershpis by group owner and other options.

Specified by:

findAllByGroupOwnerOptions in interface MembershipDAO

Parameters:

groupId - to limit memberships to

totalMemberIds - memberids to get, or blank for all

membershipType - Immediate, NonImmediate, etc

fields - if finding by fields, list here, otherwise all list fields will be returned

sources - if limiting memberships of members in certain sources, list here

enabled - null for all, true for enabled only, false for disabled only

queryOptions - for the query

Returns:

a set of membership and member objects

See Also:

MembershipDAO.findAllByGroupOwnerOptions(java.lang.String, java.util.Collection, edu.internet2.middleware.grouper.membership.MembershipType, java.util.Collection, java.util.Set, java.lang.Boolean, edu.internet2.middleware.grouper.internal.dao.QueryOptions)

findAllByGroupOwnerOptions
```
public Set<Object[]> findAllByGroupOwnerOptions(String groupId,
                                                MembershipType membershipType,
                                                Collection<Field> fields,
                                                Set<Source> sources,
                                                Boolean enabled,
                                                QueryOptions queryOptions)
```
Description copied from interface: MembershipDAO

find memberships by group owner and other options.

Specified by:

findAllByGroupOwnerOptions in interface MembershipDAO

Parameters:

groupId - to limit memberships to

membershipType - Immediate, NonImmediate, etc

fields - if finding by fields, list here, otherwise all list fields will be returned

sources - if limiting memberships of members in certain sources, list here

enabled - null for all, true for enabled only, false for disabled only

queryOptions - for the query

Returns:

a set of membership and member objects

See Also:

MembershipDAO.findAllByGroupOwnerOptions(java.lang.String, edu.internet2.middleware.grouper.membership.MembershipType, java.util.Collection, java.util.Set, java.lang.Boolean, edu.internet2.middleware.grouper.internal.dao.QueryOptions)

findAllMembershipEntriesByGroupOwnerAndFieldAndType

public Set<Membership> findAllMembershipEntriesByGroupOwnerAndFieldAndType(String ownerGroupId,
                                                                           Field f,
                                                                           String type,
                                                                           boolean enabledOnly)

Description copied from interface: MembershipDAO

In this case, membership objects are not joined with groupSets like most queries. This queries the memberships table only.

Specified by:: findAllMembershipEntriesByGroupOwnerAndFieldAndType in interface MembershipDAO
Returns:: set of memberships
See Also:: MembershipDAO.findAllMembershipEntriesByGroupOwnerAndFieldAndType(java.lang.String, edu.internet2.middleware.grouper.Field, java.lang.String, boolean)

findMissingComplementMemberships
```
public Set<Object[]> findMissingComplementMemberships()
```
Specified by:

findMissingComplementMemberships in interface MembershipDAO

Returns:

set of arrays containing owner ids, composite ids, and member ids that should be added as composite memberships

See Also:

edu.internet2.middleware.grouper.internal.dao.MembershipDAO#findMissingCompositeComplement()

findMissingUnionMemberships
```
public Set<Object[]> findMissingUnionMemberships()
```
Specified by:

findMissingUnionMemberships in interface MembershipDAO

Returns:

set of arrays containing owner ids, composite ids, and member ids that should be added as composite memberships

See Also:

MembershipDAO.findMissingUnionMemberships()

findMissingIntersectionMemberships
```
public Set<Object[]> findMissingIntersectionMemberships()
```
Specified by:

findMissingIntersectionMemberships in interface MembershipDAO

Returns:

set of arrays containing owner ids, composite ids, and member ids that should be added as composite memberships

See Also:

MembershipDAO.findMissingIntersectionMemberships()

findBadComplementMemberships
```
public Set<Membership> findBadComplementMemberships()
```
Specified by:

findBadComplementMemberships in interface MembershipDAO

Returns:

set of immediate memberships that are bad

See Also:

MembershipDAO.findBadComplementMemberships()

findBadUnionMemberships
```
public Set<Membership> findBadUnionMemberships()
```
Specified by:

findBadUnionMemberships in interface MembershipDAO

Returns:

set of immediate memberships that are bad

See Also:

MembershipDAO.findBadUnionMemberships()

findBadIntersectionMemberships
```
public Set<Membership> findBadIntersectionMemberships()
```
Specified by:

findBadIntersectionMemberships in interface MembershipDAO

Returns:

set of immediate memberships that are bad

See Also:

MembershipDAO.findBadUnionMemberships()

findBadMembershipsOnCompositeGroup
```
public Set<Membership> findBadMembershipsOnCompositeGroup()
```
Description copied from interface: MembershipDAO

This will find "immediate" memberships on composite groups along with memberships that don't have the right viaCompositeId.

Specified by:

findBadMembershipsOnCompositeGroup in interface MembershipDAO

Returns:

set of immediate memberships that are bad

See Also:

edu.internet2.middleware.grouper.internal.dao.MembershipDAO#findBadImmediateMembershipsOnCompositeGroup()

findBadMembershipsDeletedGroupAsMember
```
public Set<Membership> findBadMembershipsDeletedGroupAsMember()
```
Description copied from interface: MembershipDAO

Find cases where a membership exists where the member is a deleted group.

Specified by:

findBadMembershipsDeletedGroupAsMember in interface MembershipDAO

Returns:

set of immediate memberships that are bad

See Also:

MembershipDAO.findBadMembershipsDeletedGroupAsMember()

findBadCompositeMembershipsOnNonCompositeGroup
```
public Set<Membership> findBadCompositeMembershipsOnNonCompositeGroup()
```
Specified by:

findBadCompositeMembershipsOnNonCompositeGroup in interface MembershipDAO

Returns:

set of immediate memberships that are bad

See Also:

edu.internet2.middleware.grouper.internal.dao.MembershipDAO#findBadImmediateMembershipsOnCompositeGroup()

findByImmediateUuid
```
public Membership findByImmediateUuid(String uuid,
                                      boolean exceptionIfNull)
```
Specified by:

findByImmediateUuid in interface MembershipDAO

Returns:

membership

See Also:

MembershipDAO.findByImmediateUuid(java.lang.String, boolean)

findByImmediateUuid

public Membership findByImmediateUuid(String uuid,
                                      boolean exceptionIfNull,
                                      QueryOptions queryOptions)

Specified by:: findByImmediateUuid in interface MembershipDAO
Returns:: membership
See Also:: MembershipDAO.findByImmediateUuid(java.lang.String, boolean, QueryOptions)

findAllByStemOwnerOptions

public Set<Object[]> findAllByStemOwnerOptions(Collection<String> totalStemIds,
                                               Collection<String> totalMemberIds,
                                               Collection<String> totalMembershipIds,
                                               MembershipType membershipType,
                                               Field field,
                                               Set<Source> sources,
                                               String scope,
                                               Stem stem,
                                               Stem.Scope stemScope,
                                               Boolean enabled,
                                               Boolean checkSecurity)

Description copied from interface: MembershipDAO

find memberships by stem owner and other options.

Specified by:: findAllByStemOwnerOptions in interface MembershipDAO
Parameters:: totalStemIds - to limit memberships to; totalMemberIds - to limit memberships to; totalMembershipIds - to limit memberships to; membershipType - Immediate, NonImmediate, etc; field - if finding one field, list here, otherwise all list fields will be returned; sources - if limiting memberships of members in certain sources, list here; scope - sql like string which will have a % appended to it; stem - if looking in a certain stem; stemScope - if looking only in this stem, or all substems; enabled - null for all, true for enabled only, false for disabled only; checkSecurity - if we should check security, default to true
Returns:: a set of membership, stem, and member objects
See Also:: MembershipDAO.findAllByStemOwnerOptions(java.util.Collection, java.util.Collection, java.util.Collection, edu.internet2.middleware.grouper.membership.MembershipType, edu.internet2.middleware.grouper.Field, Set, java.lang.String, edu.internet2.middleware.grouper.Stem, edu.internet2.middleware.grouper.Stem.Scope, java.lang.Boolean, Boolean)

findAllByStemOwnerOptions

public Set<Object[]> findAllByStemOwnerOptions(Collection<String> totalStemIds,
                                               Collection<String> totalMemberIds,
                                               Collection<String> totalMembershipIds,
                                               MembershipType membershipType,
                                               Collection<Field> fields,
                                               Set<Source> sources,
                                               String scope,
                                               Stem stem,
                                               Stem.Scope stemScope,
                                               Boolean enabled,
                                               Boolean checkSecurity,
                                               QueryOptions queryOptionsForMember,
                                               String filterForMember,
                                               boolean splitScopeForMember,
                                               boolean hasFieldForMember,
                                               boolean hasMembershipTypeForMember,
                                               QueryOptions queryOptionsForStem,
                                               String scopeForStem,
                                               boolean splitScopeForStem,
                                               boolean hasFieldForStem,
                                               boolean hasMembershipTypeForStem)

Description copied from interface: MembershipDAO

find memberships by stem owner and other options.

Specified by:: findAllByStemOwnerOptions in interface MembershipDAO
Parameters:: totalStemIds - to limit memberships to; totalMemberIds - to limit memberships to; totalMembershipIds - to limit memberships to; membershipType - Immediate, NonImmediate, etc; fields - if finding one field, list here, otherwise all list fields will be returned; sources - if limiting memberships of members in certain sources, list here; scope - sql like string which will have a % appended to it; stem - if looking in a certain stem; stemScope - if looking only in this stem, or all substems; enabled - null for all, true for enabled only, false for disabled only; checkSecurity - if we should check security, default to true; queryOptionsForMember - query options for member. must include paging. if sorting then sort by member; filterForMember - if paging for member, then also filter for member; splitScopeForMember - if the scope for member has spaces in it, then split by whitespace, and find results that contain all of the scope strings; hasFieldForMember - return memberships where the member has this field, note, it will return all the memberships for those members; hasMembershipTypeForMember - return memberships where the member has this field, note, it will return all the memberships for those members; queryOptionsForStem - if paging by stem, then these are the query options; scopeForStem - scope to search for in stems if paging by stem; splitScopeForStem - if splitting scope when searching and paging by stem; hasFieldForStem - if has field for stem if paging by stem; hasMembershipTypeForStem - if paging for stems, this is the membership type to page on
Returns:: a set of membership, stem, and member objects
See Also:: edu.internet2.middleware.grouper.internal.dao.MembershipDAO#findAllByStemOwnerOptions(java.util.Collection, java.util.Collection, java.util.Collection, edu.internet2.middleware.grouper.membership.MembershipType, edu.internet2.middleware.grouper.Field, Set, java.lang.String, edu.internet2.middleware.grouper.Stem, edu.internet2.middleware.grouper.Stem.Scope, java.lang.Boolean, Boolean, QueryOptions, String, boolean, Field, MembershipType)

findAllByStemOwnerOptions

public Set<Object[]> findAllByStemOwnerOptions(Collection<String> totalStemIds,
                                               Collection<String> totalMemberIds,
                                               Collection<String> totalMembershipIds,
                                               MembershipType membershipType,
                                               Collection<Field> fields,
                                               Set<Source> sources,
                                               String scope,
                                               Stem stem,
                                               Stem.Scope stemScope,
                                               Boolean enabled,
                                               Boolean checkSecurity,
                                               QueryOptions queryOptionsForMember,
                                               String filterForMember,
                                               boolean splitScopeForMember,
                                               boolean hasFieldForMember,
                                               boolean hasMembershipTypeForMember,
                                               QueryOptions queryOptionsForStem,
                                               String scopeForStem,
                                               boolean splitScopeForStem,
                                               boolean hasFieldForStem,
                                               boolean hasMembershipTypeForStem,
                                               Boolean hasEnabledDate,
                                               Boolean hasDisabledDate,
                                               CompositeType customCompositeType,
                                               Group customCompositeGroup)

Description copied from interface: MembershipDAO

find memberships by stem owner and other options.

Specified by:: findAllByStemOwnerOptions in interface MembershipDAO
Parameters:: totalStemIds - to limit memberships to; totalMemberIds - to limit memberships to; totalMembershipIds - to limit memberships to; membershipType - Immediate, NonImmediate, etc; fields - if finding one field, list here, otherwise all list fields will be returned; sources - if limiting memberships of members in certain sources, list here; scope - sql like string which will have a % appended to it; stem - if looking in a certain stem; stemScope - if looking only in this stem, or all substems; enabled - null for all, true for enabled only, false for disabled only; checkSecurity - if we should check security, default to true; queryOptionsForMember - query options for member. must include paging. if sorting then sort by member; filterForMember - if paging for member, then also filter for member; splitScopeForMember - if the scope for member has spaces in it, then split by whitespace, and find results that contain all of the scope strings; hasFieldForMember - return memberships where the member has this field, note, it will return all the memberships for those members; hasMembershipTypeForMember - return memberships where the member has this field, note, it will return all the memberships for those members; queryOptionsForStem - if paging by stem, then these are the query options; scopeForStem - scope to search for in stems if paging by stem; splitScopeForStem - if splitting scope when searching and paging by stem; hasFieldForStem - if has field for stem if paging by stem; hasMembershipTypeForStem - if paging for stems, this is the membership type to page on
Returns:: a set of membership, stem, and member objects
See Also:: edu.internet2.middleware.grouper.internal.dao.MembershipDAO#findAllByStemOwnerOptions(java.util.Collection, java.util.Collection, java.util.Collection, edu.internet2.middleware.grouper.membership.MembershipType, java.util.Collection, java.util.Set, java.lang.String, edu.internet2.middleware.grouper.Stem, edu.internet2.middleware.grouper.Stem.Scope, java.lang.Boolean, java.lang.Boolean, edu.internet2.middleware.grouper.internal.dao.QueryOptions, java.lang.String, boolean, boolean, boolean, edu.internet2.middleware.grouper.internal.dao.QueryOptions, java.lang.String, boolean, boolean, boolean, java.lang.Boolean, java.lang.Boolean)

findAllByAttributeDefOwnerOptions

public Set<Object[]> findAllByAttributeDefOwnerOptions(Collection<String> totalAttributeDefIds,
                                                       Collection<String> totalMemberIds,
                                                       Collection<String> totalMembershipIds,
                                                       MembershipType membershipType,
                                                       Field field,
                                                       Set<Source> sources,
                                                       String scope,
                                                       Stem stem,
                                                       Stem.Scope stemScope,
                                                       Boolean enabled,
                                                       Boolean checkSecurity)

Description copied from interface: MembershipDAO

find memberships by stem owner and other options.

Specified by:: findAllByAttributeDefOwnerOptions in interface MembershipDAO
Parameters:: totalAttributeDefIds - to limit memberships to; totalMemberIds - to limit memberships to; totalMembershipIds - to limit memberships to; membershipType - Immediate, NonImmediate, etc; field - if finding one field, list here, otherwise all list fields will be returned; sources - if limiting memberships of members in certain sources, list here; scope - sql like string which will have a % appended to it; stem - if looking in a certain stem; stemScope - if looking only in this stem, or all substems; enabled - null for all, true for enabled only, false for disabled only; checkSecurity - if we should check security, default to true
Returns:: a set of membership, stem, and member objects
See Also:: MembershipDAO#findAllByAttributeDefOwnerOptions(Collection, Collection, Collection, MembershipType, Field, Set, String, Stem, Scope, Boolean, Boolean)

findAllByAttributeDefOwnerOptions

public Set<Object[]> findAllByAttributeDefOwnerOptions(Collection<String> attributeDefIds,
                                                       Collection<String> memberIds,
                                                       Collection<String> membershipIds,
                                                       MembershipType membershipType,
                                                       Collection<Field> fields,
                                                       Set<Source> sources,
                                                       String scope,
                                                       Stem stem,
                                                       Stem.Scope stemScope,
                                                       Boolean enabled,
                                                       Boolean shouldCheckSecurity,
                                                       QueryOptions queryOptionsForMember,
                                                       String filterForMember,
                                                       boolean splitScopeForMember,
                                                       boolean hasFieldForMember,
                                                       boolean hasMembershipTypeForMember,
                                                       QueryOptions queryOptionsForAttributeDef,
                                                       String scopeForAttributeDef,
                                                       boolean splitScopeForAttributeDef,
                                                       boolean hasFieldForAttributeDef,
                                                       boolean hasMembershipTypeForAttributeDef)

Description copied from interface: MembershipDAO

find memberships by stem owner and other options.

Specified by:: findAllByAttributeDefOwnerOptions in interface MembershipDAO
Parameters:: attributeDefIds - to limit memberships to; memberIds - to limit memberships to; membershipIds - to limit memberships to; membershipType - Immediate, NonImmediate, etc; fields - if finding one field, list here, otherwise all list fields will be returned; sources - if limiting memberships of members in certain sources, list here; scope - sql like string which will have a % appended to it; stem - if looking in a certain stem; stemScope - if looking only in this stem, or all substems; enabled - null for all, true for enabled only, false for disabled only; shouldCheckSecurity - if we should check security, default to true; queryOptionsForMember - if getting a list of members who have privileges, this is the paging/sorting; filterForMember - if filtering by member search string; splitScopeForMember - if splitting scope (by spaces and all terms must be in there); hasFieldForMember - if the member has a privilege; hasMembershipTypeForMember - if the membership type is for member list; queryOptionsForAttributeDef - if paging for attribute defs, then these are the query options for the overall page; scopeForAttributeDef - if paging for attribute defs, this is the scope to search for on the attribute defs; splitScopeForAttributeDef - if scoping and paging for attribute defs, this will split the scope by whitespace; hasFieldForAttributeDef - if paging by attribute def you can look for a specific field for the attribute defs and then all fields for the resulting attribute defs; hasMembershipTypeForAttributeDef - if paging for attribute defs, this is the membership type
Returns:: a set of membership, stem, and member objects
See Also:: MembershipDAO#findAllByAttributeDefOwnerOptions(Collection, Collection, Collection, MembershipType, Collection, Set, String, Stem, Scope, Boolean, Boolean, QueryOptions, String, boolean, boolean, boolean)

findAllByAttributeDefOwnerOptions

public Set<Object[]> findAllByAttributeDefOwnerOptions(Collection<String> attributeDefIds,
                                                       Collection<String> memberIds,
                                                       Collection<String> membershipIds,
                                                       MembershipType membershipType,
                                                       Collection<Field> fields,
                                                       Set<Source> sources,
                                                       String scope,
                                                       Stem stem,
                                                       Stem.Scope stemScope,
                                                       Boolean enabled,
                                                       Boolean shouldCheckSecurity,
                                                       QueryOptions queryOptionsForMember,
                                                       String filterForMember,
                                                       boolean splitScopeForMember,
                                                       boolean hasFieldForMember,
                                                       boolean hasMembershipTypeForMember,
                                                       QueryOptions queryOptionsForAttributeDef,
                                                       String scopeForAttributeDef,
                                                       boolean splitScopeForAttributeDef,
                                                       boolean hasFieldForAttributeDef,
                                                       boolean hasMembershipTypeForAttributeDef,
                                                       Boolean hasEnabledDate,
                                                       Boolean hasDisabledDate,
                                                       CompositeType customCompositeType,
                                                       Group customCompositeGroup)

Description copied from interface: MembershipDAO

find memberships by stem owner and other options.

Specified by:: findAllByAttributeDefOwnerOptions in interface MembershipDAO
Parameters:: attributeDefIds - to limit memberships to; memberIds - to limit memberships to; membershipIds - to limit memberships to; membershipType - Immediate, NonImmediate, etc; fields - if finding one field, list here, otherwise all list fields will be returned; sources - if limiting memberships of members in certain sources, list here; scope - sql like string which will have a % appended to it; stem - if looking in a certain stem; stemScope - if looking only in this stem, or all substems; enabled - null for all, true for enabled only, false for disabled only; shouldCheckSecurity - if we should check security, default to true; queryOptionsForMember - if getting a list of members who have privileges, this is the paging/sorting; filterForMember - if filtering by member search string; splitScopeForMember - if splitting scope (by spaces and all terms must be in there); hasFieldForMember - if the member has a privilege; hasMembershipTypeForMember - if the membership type is for member list; queryOptionsForAttributeDef - if paging for attribute defs, then these are the query options for the overall page; scopeForAttributeDef - if paging for attribute defs, this is the scope to search for on the attribute defs; splitScopeForAttributeDef - if scoping and paging for attribute defs, this will split the scope by whitespace; hasFieldForAttributeDef - if paging by attribute def you can look for a specific field for the attribute defs and then all fields for the resulting attribute defs; hasMembershipTypeForAttributeDef - if paging for attribute defs, this is the membership type
Returns:: a set of membership, stem, and member objects
See Also:: edu.internet2.middleware.grouper.internal.dao.MembershipDAO#findAllByAttributeDefOwnerOptions(java.util.Collection, java.util.Collection, java.util.Collection, edu.internet2.middleware.grouper.membership.MembershipType, java.util.Collection, java.util.Set, java.lang.String, edu.internet2.middleware.grouper.Stem, edu.internet2.middleware.grouper.Stem.Scope, java.lang.Boolean, java.lang.Boolean, edu.internet2.middleware.grouper.internal.dao.QueryOptions, java.lang.String, boolean, boolean, boolean, edu.internet2.middleware.grouper.internal.dao.QueryOptions, java.lang.String, boolean, boolean, boolean, java.lang.Boolean, java.lang.Boolean)

findAllByAttributeDefOwnerOptions

public Set<Object[]> findAllByAttributeDefOwnerOptions(Collection<String> attributeDefIds,
                                                       Collection<String> memberIds,
                                                       Collection<String> membershipIds,
                                                       MembershipType membershipType,
                                                       Collection<Field> fields,
                                                       Set<Source> sources,
                                                       String scope,
                                                       Stem stem,
                                                       Stem.Scope stemScope,
                                                       Boolean enabled,
                                                       Boolean shouldCheckSecurity,
                                                       QueryOptions queryOptionsForAttributeDef,
                                                       String scopeForAttributeDef,
                                                       boolean splitScopeForAttributeDef,
                                                       boolean hasFieldForAttributeDef,
                                                       boolean hasMembershipTypeForAttributeDef)

Description copied from interface: MembershipDAO

find memberships by stem owner and other options.

Specified by:: findAllByAttributeDefOwnerOptions in interface MembershipDAO
Parameters:: attributeDefIds - to limit memberships to; memberIds - to limit memberships to; membershipIds - to limit memberships to; membershipType - Immediate, NonImmediate, etc; fields - if finding one field, list here, otherwise all list fields will be returned; sources - if limiting memberships of members in certain sources, list here; scope - sql like string which will have a % appended to it; stem - if looking in a certain stem; stemScope - if looking only in this stem, or all substems; enabled - null for all, true for enabled only, false for disabled only; shouldCheckSecurity - if we should check security, default to true; queryOptionsForAttributeDef - if paging for attribute defs, then these are the query options for the overall page; scopeForAttributeDef - if paging for attribute defs, this is the scope to search for on the attribute defs; splitScopeForAttributeDef - if scoping and paging for attribute defs, this will split the scope by whitespace; hasFieldForAttributeDef - if paging by attribute def you can look for a specific field for the attribute defs and then all fields for the resulting attribute defs; hasMembershipTypeForAttributeDef - if paging for attribute defs, this is the membership type
Returns:: a set of membership, stem, and member objects
See Also:: MembershipDAO#findAllByAttributeDefOwnerOptions(Collection, Collection, Collection, MembershipType, Collection, Set, String, Stem, Scope, Boolean, Boolean, QueryOptions, String, boolean, boolean, boolean)

Class Hib3MembershipDAO

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

Hib3MembershipDAO

Method Detail

findAll

findAllByCreatorOrMember

findAllByCreatedAfter

findAllByCreatedBefore

findAllByMember

findAllByGroupOwnerAndField

findAllByStemOwnerAndField

findAllByStemOwnerAndFieldAndType

findAllByGroupOwnerAndFieldAndType

findAllByGroupOwnerAndFieldAndDepth

findAllByGroupOwnerAndDepth

findAllByMemberAndDepth

findAllByStemOwnerAndMemberAndField

findAllByGroupOwnerAndMemberAndField

findAllMembersByGroupOwnerAndField

findAllMembersByGroupOwnerAndField

findAllMembersByGroupOwnerAndField

findAllMembersByGroupOwnerAndFieldAndType

findAllByGroupOwnerOptions

findAllByGroupOwnerOptions

findAllByGroupOwnerOptions

findAllByGroupOwnerOptions

findAllByGroupOwnerOptions

findAllByGroupOwnerOptions

findAllMembersByGroupOwnerAndFieldAndType

findAllMembersByOwnerAndFieldAndType

findAllMembersByStemOwnerAndFieldAndType

findAllByGroupOwnerAndFieldAndMembersAndType

findAllByGroupOwnerAndFieldAndMemberIdsAndType

findAllByGroupOwnerAndFieldAndMembers

findAllByGroupOwnerAndCompositeAndMembers

findByGroupOwnerAndMemberAndFieldAndType

findByStemOwnerAndMemberAndFieldAndType

findAllChildMemberships

findAllEffectiveByGroupOwner

findAllEffectiveByStemOwner

findAllEffectiveByMemberAndField

findAllEffectiveByGroupOwnerAndMemberAndField

findAllByGroupOwnerAndMember

findAllImmediateByMember

findAllByGroupOwnerAsList

findAllByStemOwnerAsList

findAllImmediateByMemberAndField

findAllImmediateByMemberAndFieldType

findByUuid

findByUuid

findMembershipsByMemberAndFieldSecure

save

save

delete

update

delete

update

reset

findParentMembership

findMissingImmediateGroupSetsForGroupOwners

findMissingImmediateGroupSetsForStemOwners

findByAttrDefOwnerAndMemberAndFieldAndType

findAllEffectiveByAttrDefOwner

findAllMembersByAttrDefOwnerAndFieldAndType

findMissingImmediateGroupSetsForAttrDefOwners

findAllByAttrDefOwnerAndField

findAllByAttrDefOwnerAndFieldAndType

findAllByAttrDefOwnerAndMemberAndField

findAllByAttrDefOwnerAsList

findAllImmediateByAttrDefOwnerAsList

findAllByAttrDefOwnerAndMember

findAllEnabledDisabledMismatch

findAllNonImmediateByMember

findAllNonImmediateByMemberAndField

findAllNonImmediateByMemberAndFieldType

findByImmediateUuidOrKey