edu.internet2.middleware.grouper.internal.dao
Interface MembershipDAO

All Superinterfaces:

GrouperDAO

All Known Implementing Classes:

Hib3MembershipDAO

public interface MembershipDAO
extends GrouperDAO

Basic Membership DAO interface.

Since:

1.2.0

Version:

$Id: MembershipDAO.java,v 1.35 2009-12-17 06:57:57 mchyzer Exp $

Author:

blair christensen.

findAllEnabledDisabledMismatch

Set<Membership> findAllEnabledDisabledMismatch()

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

Returns:

the memberships

findAll

Set<Membership> findAll(boolean enabledOnly)

get all memberships

Parameters:

enabledOnly -

Returns:

set

findAllByCreatedAfter

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

Parameters:

d -

f -

enabledOnly -

Returns:

set of membership

Throws:

GrouperDAOException

Since:

1.2.0

findAllByCreatedBefore

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

Parameters:

d -

f -

enabledOnly -

Returns:

set

Throws:

GrouperDAOException

Since:

1.2.0

findAllByMember

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

Parameters:

memberUUID -

enabledOnly -

Returns:

set

Throws:

GrouperDAOException

Since:

1.2.0

findAllByGroupOwnerAndField

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

Parameters:

ownerGroupId -

f -

enabledOnly -

Returns:

set

Throws:

GrouperDAOException

Since:

1.2.0

findAllByStemOwnerAndField

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

Parameters:

ownerStemId -

f -

enabledOnly -

Returns:

set

Throws:

GrouperDAOException

Since:

1.2.0

findAllByGroupOwnerAndFieldAndType

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

Parameters:

ownerGroupId -

f -

type -

enabledOnly -

Returns:

set

Throws:

GrouperDAOException

Since:

1.2.0

findAllByStemParentOfGroupOwnerAndFieldAndType

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

Parameters:

stem -

stemScope -

field -

type - e.g. immediate

enabledOnly -

memberId -

Returns:

set

Throws:

GrouperDAOException

Since:

1.2.0

findAllByStemOwnerAndFieldAndType

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

Parameters:

ownerStemId -

f -

type -

enabledOnly -

Returns:

set

Throws:

GrouperDAOException

Since:

1.2.0

findAllByGroupOwnerAndMemberAndField

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

Parameters:

ownerGroupId -

memberUUID -

f -

enabledOnly -

Returns:

set

Throws:

GrouperDAOException

Since:

1.2.0

findAllByGroupOwnerAndFieldAndMembers

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

TODO update for 1.5

Parameters:

ownerUUID -

f -

members -

enabledOnly -

Returns:

set

Throws:

GrouperDAOException

Since:

1.2.1

findAllByGroupOwnerAndFieldAndMembersAndType

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

Parameters:

ownerUUID -

f -

members -

type -

enabledOnly -

Returns:

set

Throws:

GrouperDAOException

findAllByGroupOwnerAndFieldAndMemberIdsAndType

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

Parameters:

ownerUUID -

f -

memberIds -

type -

enabledOnly -

Returns:

set

Throws:

GrouperDAOException

findAllByGroupOwnerAndCompositeAndMembers

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

Parameters:

ownerUUID -

members -

enabledOnly -

Returns:

set

Throws:

GrouperDAOException

findAllByGroupOwnerAndMember

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

Parameters:

groupOwnerId -

memberUUID -

enabledOnly -

Returns:

set

Throws:

GrouperDAOException

Since:

1.2.1

findAllMembersByGroupOwnerAndFieldAndType

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

Parameters:

ownerGroupId -

f -

type -

queryOptions -

enabledOnly -

Returns:

set

Throws:

GrouperDAOException

findAllMembersInOneGroupNotOtherAndType

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

Parameters:

ownerInGroupId -

ownerNotInGroupId -

typeIn -

typeNotIn -

queryOptions -

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

findAllMembersInOneGroupNotStem

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

Parameters:

ownerInGroupId -

ownerNotInStem -

stemScope -

typeIn -

queryOptions -

Returns:

set

Throws:

GrouperDAOException

findAllMembersByGroupOwnerAndFieldAndType

Set<Member> findAllMembersByGroupOwnerAndFieldAndType(String ownerGroupId,
                                                      Field f,
                                                      String type,
                                                      Set<edu.internet2.middleware.subject.Source> sources,
                                                      QueryOptions queryOptions,
                                                      boolean enabledOnly)
                                                      throws GrouperDAOException

Parameters:

ownerGroupId -

f -

type -

sources -

queryOptions -

enabledOnly -

Returns:

set

Throws:

GrouperDAOException

findAllMembersByOwnerAndFieldAndType

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

Parameters:

ownerId -

f -

type -

sources -

queryOptions -

enabledOnly -

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

findAllMembersByStemOwnerAndFieldAndType

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

note, dont change this signature, Arnaud is using it

Parameters:

ownerStemId -

f -

type -

queryOptions -

enabledOnly -

Returns:

set

Throws:

GrouperDAOException

findAllByStemOwnerAndMemberAndField

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

Parameters:

ownerStemId -

memberUUID -

f -

enabledOnly -

Returns:

set

Throws:

GrouperDAOException

Since:

1.2.0

findAllMembersByGroupOwnerAndField

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

Parameters:

ownerGroupId -

f -

enabledOnly -

Returns:

Members from memberships.

Throws:

GrouperDAOException - if any DAO errors occur.

Since:

1.2.1

See Also:

findAllMembersByGroupOwnerAndField(String, Field, boolean)

findAllMembershipsByGroupOwnerFieldDisabledRange

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

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

Parameters:

ownerGroupId - memberships in this owner

field -

disabledDateFrom - null if dont consider

disabledDateTo - null if dont consider

Returns:

memberships.

findAllMembersByGroupOwnerAndField

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

Parameters:

groupOwnerId -

f -

queryOptions -

enabledOnly -

Returns:

the members

Throws:

GrouperDAOException

findAllMembersByGroupOwnerAndField

Set<Member> findAllMembersByGroupOwnerAndField(String groupOwnerId,
                                               Field f,
                                               Set<edu.internet2.middleware.subject.Source> sources,
                                               QueryOptions queryOptions,
                                               boolean enabledOnly)
                                               throws GrouperDAOException

Parameters:

groupOwnerId -

f -

sources -

queryOptions -

enabledOnly -

Returns:

the members

Throws:

GrouperDAOException

findByGroupOwnerAndMemberAndFieldAndType

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

Parameters:

ownerGroupId -

memberUUID -

f -

type -

exceptionIfNull -

enabledOnly -

Returns:

membership

Throws:

GrouperDAOException

MembershipNotFoundException

findByStemOwnerAndMemberAndFieldAndType

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

Parameters:

ownerStemId -

memberUUID -

f -

type -

exceptionIfNull -

enabledOnly -

Returns:

membership

Throws:

GrouperDAOException

MembershipNotFoundException

findByAttrDefOwnerAndMemberAndFieldAndType

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

Parameters:

ownerAttrDefId -

memberUUID -

f -

type -

exceptionIfNull -

enabledOnly -

Returns:

membership

Throws:

GrouperDAOException

MembershipNotFoundException

findAllChildMemberships

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

Parameters:

_ms -

enabledOnly -

Returns:

set

Throws:

GrouperDAOException

Since:

1.2.0

findParentMembership

Membership findParentMembership(Membership _ms)
                                throws GrouperDAOException

Parameters:

_ms -

Returns:

membership

Throws:

GrouperDAOException

Since:

1.5.0

findAllEffectiveByGroupOwner

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

Parameters:

ownerGroupId -

memberUUID -

f -

viaGroupId -

depth -

enabledOnly -

Returns:

set

Throws:

GrouperDAOException

Since:

1.2.0

findAllEffectiveByStemOwner

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

Parameters:

ownerStemId -

memberUUID -

f -

viaGroupId -

depth -

enabledOnly -

Returns:

set

Throws:

GrouperDAOException

Since:

1.2.0

findAllByGroupOwnerOptions

Set<Object[]> findAllByGroupOwnerOptions(Collection<String> groupIds,
                                         Collection<String> memberIds,
                                         Collection<String> membershipIds,
                                         MembershipType membershipType,
                                         Field field,
                                         Set<edu.internet2.middleware.subject.Source> sources,
                                         String scope,
                                         Stem stem,
                                         Stem.Scope stemScope,
                                         Boolean enabled)

find membershpis by group owner and other options.

Parameters:

groupIds - to limit memberships to

memberIds - to limit memberships to

membershipIds - 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

findAllByGroupOwnerOptions

Set<Object[]> findAllByGroupOwnerOptions(Collection<String> groupIds,
                                         Collection<String> memberIds,
                                         Collection<String> membershipIds,
                                         MembershipType membershipType,
                                         Field field,
                                         Set<edu.internet2.middleware.subject.Source> sources,
                                         String scope,
                                         Stem stem,
                                         Stem.Scope stemScope,
                                         Boolean enabled,
                                         Boolean shouldCheckSecurity)

find membershpis by group owner and other options.

Parameters:

groupIds - to limit memberships to

memberIds - to limit memberships to

membershipIds - 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

shouldCheckSecurity - if we should check security, default to true

Returns:

a set of membership, group, and member objects

findAllByGroupOwnerOptions

Set<Object[]> findAllByGroupOwnerOptions(Collection<String> groupIds,
                                         Collection<String> memberIds,
                                         Collection<String> membershipIds,
                                         MembershipType membershipType,
                                         Collection<Field> fields,
                                         Collection<Privilege> privilegesTheUserHas,
                                         Set<edu.internet2.middleware.subject.Source> sources,
                                         String scope,
                                         Stem stem,
                                         Stem.Scope stemScope,
                                         Boolean enabled,
                                         Boolean shouldCheckSecurity,
                                         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.

Parameters:

groupIds - 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

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

shouldCheckSecurity - if we should check security, default to true

fieldType - field type of of memberships

serviceId -

serviceRole -

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

queryOptionsForGroup -

scopeForGroup -

splitScopeForGroup -

hasFieldForGroup -

hasMembershipTypeForGroup -

memberHasMembershipForGroup - makes sure this member has a membership in the group before returning any results

Returns:

a set of membership, group, and member objects

Since:

v2.2

findAllByGroupOwnerOptions

Set<Object[]> findAllByGroupOwnerOptions(Collection<String> groupIds,
                                         Collection<String> memberIds,
                                         Collection<String> membershipIds,
                                         MembershipType membershipType,
                                         Field field,
                                         Set<edu.internet2.middleware.subject.Source> sources,
                                         String scope,
                                         Stem stem,
                                         Stem.Scope stemScope,
                                         Boolean enabled,
                                         Boolean shouldCheckSecurity,
                                         FieldType fieldType)

find membershpis by group owner and other options.

Parameters:

groupIds - to limit memberships to

memberIds - to limit memberships to

membershipIds - 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

shouldCheckSecurity - 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

findAllMembersByAttributeDefOwnerOptions

List<Member> findAllMembersByAttributeDefOwnerOptions(String attributeDefId,
                                                      MembershipType membershipType,
                                                      Collection<Field> fields,
                                                      Set<edu.internet2.middleware.subject.Source> sources,
                                                      Boolean enabled,
                                                      QueryOptions queryOptions)

find memberships by attribute def owner and other options.

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

findAllByAttributeDefOwnerOptions

Set<Object[]> findAllByAttributeDefOwnerOptions(String attributeDefId,
                                                MembershipType membershipType,
                                                Collection<Field> fields,
                                                Set<edu.internet2.middleware.subject.Source> sources,
                                                Boolean enabled,
                                                QueryOptions queryOptions)

find memberships by attribute def owner and other options.

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

findAllByAttributeDefOwnerOptions

Set<Object[]> findAllByAttributeDefOwnerOptions(String attributeDefId,
                                                Collection<String> memberIds,
                                                MembershipType membershipType,
                                                Collection<Field> fields,
                                                Set<edu.internet2.middleware.subject.Source> sources,
                                                Boolean enabled,
                                                QueryOptions queryOptions)

find membershpis by attribute def owner and other options.

Parameters:

attributeDefId - to limit memberships to

memberIds - 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

findSourceIdsByGroupOwnerOptions

Set<String> findSourceIdsByGroupOwnerOptions(String groupId,
                                             MembershipType membershipType,
                                             Field field,
                                             Boolean enabled)

find membershpis by group owner and other options.

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

findAllEffectiveByMemberAndField

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

Parameters:

memberUUID -

f -

enabledOnly -

Returns:

set

Throws:

GrouperDAOException

Since:

1.2.0

findAllEffectiveByGroupOwnerAndMemberAndField

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

Parameters:

ownerGroupId -

memberUUID -

f -

enabledOnly -

Returns:

set

Throws:

GrouperDAOException

Since:

1.2.0

findAllImmediateByMemberAndField

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

Parameters:

memberUUID -

f -

enabledOnly -

Returns:

set

Throws:

GrouperDAOException

Since:

1.2.0

findAllNonImmediateByMemberAndField

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

Parameters:

memberUUID -

f -

enabledOnly -

Returns:

set

Throws:

GrouperDAOException

Since:

1.2.0

findAllImmediateByMemberAndFieldType

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

Parameters:

memberUUID -

fieldType -

enabledOnly -

Returns:

set

Throws:

GrouperDAOException

Since:

1.2.0

findAllImmediateByMember

Set findAllImmediateByMember(String memberUUID,
                             boolean enabledOnly)
                             throws GrouperDAOException

Parameters:

memberUUID -

enabledOnly -

Returns:

set

Throws:

GrouperDAOException

Since:

1.3.1

findAllByGroupOwnerAsList

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

Parameters:

ownerUUID -

enabledOnly -

Returns:

list

Throws:

GrouperDAOException

Since:

1.3.1

findAllByStemOwnerAsList

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

Parameters:

ownerUUID -

enabledOnly -

Returns:

list

Throws:

GrouperDAOException

Since:

1.3.1

findByUuid

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

Parameters:

uuid -

exceptionIfNull -

enabledOnly -

Returns:

membership

Throws:

GrouperDAOException

MembershipNotFoundException

findByUuid

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

Parameters:

uuid -

exceptionIfNull -

enabledOnly -

queryOptions -

Returns:

membership

Throws:

GrouperDAOException

MembershipNotFoundException

findMembershipsByMemberAndFieldSecure

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

find memberships that the user is allowed to see

Parameters:

grouperSession -

memberUUID -

f -

enabledOnly -

Returns:

the memberships

Throws:

GrouperDAOException

save

void save(Membership ms)

Save a membership

Parameters:

ms -

save

void save(Set<Membership> mships)

Save a set of memberships

Parameters:

mships -

delete

void delete(Membership ms)

Delete a membership

Parameters:

ms -

update

void update(Membership ms)

Update a membership

Parameters:

ms -

update

void update(Set<Membership> mships)

Update a set of memberships

Parameters:

mships -

delete

void delete(Set<Membership> mships)

Delete a set of memberships

Parameters:

mships -

findAllByCreatorOrMember

Set<Membership> findAllByCreatorOrMember(Member member,
                                         boolean enabledOnly)

find all memberships that have this member or have this creator

Parameters:

member -

enabledOnly -

Returns:

the memberships

findAllByGroupOwnerAndFieldAndDepth

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

Parameters:

ownerGroupId -

f -

depth -

enabledOnly -

Returns:

set

findMissingImmediateGroupSetsForGroupOwners

Set<Membership> findMissingImmediateGroupSetsForGroupOwners()

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

Returns:

set of memberships for which a groupSet is missing

findMissingImmediateGroupSetsForStemOwners

Set<Membership> findMissingImmediateGroupSetsForStemOwners()

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

Returns:

set of memberships for which a groupSet is missing

findMissingImmediateGroupSetsForAttrDefOwners

Set<Membership> findMissingImmediateGroupSetsForAttrDefOwners()

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

Returns:

set of memberships for which a groupSet is missing

findAllMembersByAttrDefOwnerAndFieldAndType

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

Parameters:

ownerAttrDefId -

f -

type -

queryOptions -

enabledOnly -

Returns:

set

Throws:

GrouperDAOException

findAllEffectiveByAttrDefOwner

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

Parameters:

ownerAttrDefId -

memberUUID -

f -

viaGroupId -

depth -

enabledOnly -

Returns:

set

Throws:

GrouperDAOException

Since:

1.2.0

findAllByAttrDefOwnerAndField

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

Parameters:

ownerAttrDefId -

f -

enabledOnly -

Returns:

set

Throws:

GrouperDAOException

Since:

1.2.0

findAllByAttrDefOwnerAndMember

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

Parameters:

ownerAttrDefId -

memberUUID -

enabledOnly -

Returns:

set

Throws:

GrouperDAOException

Since:

1.2.1

findAllByAttrDefOwnerAndFieldAndType

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

Parameters:

ownerAttrDefId -

f -

type -

enabledOnly -

Returns:

set

Throws:

GrouperDAOException

Since:

1.2.0

findAllByAttrDefOwnerAndMemberAndField

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

Parameters:

ownerAttrDefId -

memberUUID -

f -

enabledOnly -

Returns:

set

Throws:

GrouperDAOException

Since:

1.2.0

findAllByAttrDefOwnerAsList

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

Parameters:

attrDefId -

enabledOnly -

Returns:

list

Throws:

GrouperDAOException

Since:

1.3.1

findAllImmediateByAttrDefOwnerAsList

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

Parameters:

attrDefId -

enabledOnly -

Returns:

list

Throws:

GrouperDAOException

findAllNonImmediateByMember

Set findAllNonImmediateByMember(String memberUUID,
                                boolean enabledOnly)
                                throws GrouperDAOException

Parameters:

memberUUID -

enabledOnly -

Returns:

set

Throws:

GrouperDAOException

Since:

1.3.1

findAllNonImmediateByMemberAndFieldType

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

Parameters:

memberUUID -

fieldType -

enabledOnly -

Returns:

set

Throws:

GrouperDAOException

Since:

1.2.0

findByImmediateUuidOrKey

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

Parameters:

uuid -

memberUUID -

fieldId -

ownerAttrDefId -

ownerGroupId -

ownerStemId -

exceptionIfNull -

Returns:

the stem or null

Throws:

GrouperDAOException

GroupNotFoundException

Since:

1.6.0

findByImmediateUuid

Membership findByImmediateUuid(String uuid,
                               boolean exceptionIfNull)

Parameters:

uuid -

exceptionIfNull -

Returns:

membership

findByImmediateUuid

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

Parameters:

uuid -

exceptionIfNull -

queryOptions -

Returns:

membership

saveUpdateProperties

void saveUpdateProperties(Membership membership)

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

Parameters:

membership -

findAllMembersByGroupOwnerOptions

List<Member> findAllMembersByGroupOwnerOptions(String groupId,
                                               MembershipType membershipType,
                                               Collection<Field> fields,
                                               Set<edu.internet2.middleware.subject.Source> sources,
                                               Boolean enabled,
                                               QueryOptions queryOptions)

find memberships by attribute def owner and other options.

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

findAllByGroupOwnerOptions

Set<Object[]> findAllByGroupOwnerOptions(String groupId,
                                         Collection<String> memberIds,
                                         MembershipType membershipType,
                                         Collection<Field> fields,
                                         Set<edu.internet2.middleware.subject.Source> sources,
                                         Boolean enabled,
                                         QueryOptions queryOptions)

find membershpis by group owner and other options.

Parameters:

groupId - to limit memberships to

memberIds - 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

findAllByGroupOwnerOptions

Set<Object[]> findAllByGroupOwnerOptions(String groupId,
                                         MembershipType membershipType,
                                         Collection<Field> fields,
                                         Set<edu.internet2.middleware.subject.Source> sources,
                                         Boolean enabled,
                                         QueryOptions queryOptions)

find memberships by group owner and other options.

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

findAllMembershipEntriesByGroupOwnerAndFieldAndType

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

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

Parameters:

ownerGroupId -

f -

type -

enabledOnly -

Returns:

set of memberships

findMissingComplementMemberships

Set<Object[]> findMissingComplementMemberships()

Returns:

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

findMissingUnionMemberships

Set<Object[]> findMissingUnionMemberships()

Returns:

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

findMissingIntersectionMemberships

Set<Object[]> findMissingIntersectionMemberships()

Returns:

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

findBadComplementMemberships

Set<Membership> findBadComplementMemberships()

Returns:

set of immediate memberships that are bad

findBadUnionMemberships

Set<Membership> findBadUnionMemberships()

Returns:

set of immediate memberships that are bad

findBadIntersectionMemberships

Set<Membership> findBadIntersectionMemberships()

Returns:

set of immediate memberships that are bad

findBadMembershipsOnCompositeGroup

Set<Membership> findBadMembershipsOnCompositeGroup()

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

Returns:

set of immediate memberships that are bad

findBadCompositeMembershipsOnNonCompositeGroup

Set<Membership> findBadCompositeMembershipsOnNonCompositeGroup()

Returns:

set of immediate memberships that are bad

findBadMembershipsDeletedGroupAsMember

Set<Membership> findBadMembershipsDeletedGroupAsMember()

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

Returns:

set of immediate memberships that are bad

findAllByStemOwnerOptions

Set<Object[]> findAllByStemOwnerOptions(Collection<String> stemIds,
                                        Collection<String> memberIds,
                                        Collection<String> membershipIds,
                                        MembershipType membershipType,
                                        Field field,
                                        Set<edu.internet2.middleware.subject.Source> sources,
                                        String scope,
                                        Stem stem,
                                        Stem.Scope stemScope,
                                        Boolean enabled,
                                        Boolean shouldCheckSecurity)

find memberships by stem owner and other options.

Parameters:

stemIds - to limit memberships to

memberIds - to limit memberships to

membershipIds - 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

shouldCheckSecurity - if we should check security, default to true

Returns:

a set of membership, stem, and member objects

findAllByStemOwnerOptions

Set<Object[]> findAllByStemOwnerOptions(Collection<String> stemIds,
                                        Collection<String> memberIds,
                                        Collection<String> membershipIds,
                                        MembershipType membershipType,
                                        Collection<Field> field,
                                        Set<edu.internet2.middleware.subject.Source> sources,
                                        String scope,
                                        Stem stem,
                                        Stem.Scope stemScope,
                                        Boolean enabled,
                                        Boolean shouldCheckSecurity,
                                        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.

Parameters:

stemIds - to limit memberships to

memberIds - to limit memberships to

membershipIds - 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

shouldCheckSecurity - 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

Since:

v2.2

findAllByAttributeDefOwnerOptions

Set<Object[]> findAllByAttributeDefOwnerOptions(Collection<String> attributeDefIds,
                                                Collection<String> memberIds,
                                                Collection<String> membershipIds,
                                                MembershipType membershipType,
                                                Field field,
                                                Set<edu.internet2.middleware.subject.Source> sources,
                                                String scope,
                                                Stem stem,
                                                Stem.Scope stemScope,
                                                Boolean enabled,
                                                Boolean shouldCheckSecurity)

find memberships by stem owner and other options.

Parameters:

attributeDefIds - to limit memberships to

memberIds - to limit memberships to

membershipIds - 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

shouldCheckSecurity - if we should check security, default to true

Returns:

a set of membership, stem, and member objects

findAllByAttributeDefOwnerOptions

Set<Object[]> findAllByAttributeDefOwnerOptions(Collection<String> attributeDefIds,
                                                Collection<String> memberIds,
                                                Collection<String> membershipIds,
                                                MembershipType membershipType,
                                                Collection<Field> field,
                                                Set<edu.internet2.middleware.subject.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.

Parameters:

attributeDefIds - to limit memberships to

memberIds - to limit memberships to

membershipIds - 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

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

Since:

v2.2

findAllByAttributeDefOwnerOptions

Set<Object[]> findAllByAttributeDefOwnerOptions(Collection<String> attributeDefIds,
                                                Collection<String> memberIds,
                                                Collection<String> membershipIds,
                                                MembershipType membershipType,
                                                Collection<Field> field,
                                                Set<edu.internet2.middleware.subject.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.

Parameters:

attributeDefIds - to limit memberships to

memberIds - to limit memberships to

membershipIds - 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

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

Since:

v2.2