Package com.atlassian.crowd.dao.membership

Class MembershipDAOHibernate

java.lang.Object
com.atlassian.crowd.util.persistence.hibernate.StatelessDao
com.atlassian.crowd.util.persistence.hibernate.HibernateDao<InternalMembership>
com.atlassian.crowd.dao.membership.MembershipDAOHibernate
All Implemented Interfaces:
InternalMembershipDao, MembershipDao
public class MembershipDAOHibernate extends HibernateDao<InternalMembership> implements MembershipDao, InternalMembershipDao

  • Field Details

  • Constructor Details

    • MembershipDAOHibernate

      public MembershipDAOHibernate()

  • Method Details

    • addAll

      public BatchResult<InternalMembership> addAll(Set<InternalMembership> memberships)
      Description copied from interface: InternalMembershipDao
      Bulk add of memberships.
      Specified by:
      addAll in interface InternalMembershipDao
      Parameters:
      memberships - Set of memberships.
      Returns:
      Batch result.

    • removeAll

      public BatchResult<InternalMembership> removeAll(Set<InternalMembership> memberships)

    • getMembershipsCreatedAfter

      public List<InternalMembership> getMembershipsCreatedAfter(long directoryId, Date timestamp, int maxResults)
      Description copied from interface: InternalMembershipDao
      Retrieves memberships with the creation timestamp greater than the specified date
      Specified by:
      getMembershipsCreatedAfter in interface InternalMembershipDao
      Parameters:
      directoryId - the id of the directory to search
      timestamp - the date to limit the search by
      maxResults - the maximum number of results to return
      Returns:

    • addAllUsersToGroup

      public BatchResult<String> addAllUsersToGroup(long directoryId, Collection<String> userNames, String groupName) throws GroupNotFoundException
      Description copied from interface: MembershipDao
      Bulk adds all the given users into the given group. Users that are already direct members of the group are reported as failures. Usernames that cannot be found in the database are also reported as failures. Implementations must make sure that changes in bulk methods such as this are immediately visible to other bulk methods. For example, if this is run in a transaction, either that transaction must be committed when this method returns, or all other bulk method implementations must guarantee to reuse the same transaction.
      Specified by:
      addAllUsersToGroup in interface MembershipDao
      Parameters:
      directoryId - the directory to perform the operation
      userNames - the collection of users
      groupName - name of the group
      Returns:
      result containing both successful (membership successfully added) and failed users (unknown username, or already existing membership)
      Throws:
      GroupNotFoundException - if the group does not exist

    • addGroupToGroup

      public void addGroupToGroup(long directoryId, String childGroup, String parentGroup) throws GroupNotFoundException, MembershipAlreadyExistsException
      Description copied from interface: MembershipDao
      Adds group as a child of the (supposedly) parent group.
      Specified by:
      addGroupToGroup in interface MembershipDao
      Parameters:
      directoryId - the directory to perform the operation
      childGroup - the (supposedly) child group
      parentGroup - parent group
      Throws:
      GroupNotFoundException - if either child or parent group is not found
      MembershipAlreadyExistsException - if the child group is already a child of the parent group

    • addAllGroupsToGroup

      public BatchResult<String> addAllGroupsToGroup(long directoryId, Collection<String> childGroupNames, String groupName) throws GroupNotFoundException
      Description copied from interface: MembershipDao
      Bulk adds all the given child groups into the given group. Child groups that are already direct members of the group are reported as failures. childGroupNames that cannot be found in the database are also reported as failures. Implementations must make sure that changes in bulk methods such as this are immediately visible to other bulk methods. For example, if this is run in a transaction, either that transaction must be committed when this method returns, or all other bulk method implementations must guarantee to reuse the same transaction.
      Specified by:
      addAllGroupsToGroup in interface MembershipDao
      Parameters:
      directoryId - the directory to perform the operation
      childGroupNames - the collection of child groups to add
      groupName - name of the group
      Returns:
      result containing both successful (membership successfully added) and failed groups (unknown childGroupName, or already existing membership)
      Throws:
      GroupNotFoundException - if the group does not exist

    • addUserToGroups

      public BatchResult<String> addUserToGroups(long directoryId, String username, Set<String> groupNames) throws UserNotFoundException
      Description copied from interface: MembershipDao
      Bulk adds the given user to all the given groups. Groups that user is already a direct member of are reported as failures. Group names that cannot be found in the database are also reported as failures. Implementations must make sure that changes in bulk methods such as this are immediately visible to other bulk methods. For example, if this is run in a transaction, either that transaction must be committed when this method returns, or all other bulk method implementations must guarantee to reuse the same transaction.
      Specified by:
      addUserToGroups in interface MembershipDao
      Parameters:
      directoryId - the id of the directory to which user and groups belong
      username - username of the user to whom we add groups
      groupNames - names of the group to add to a user. The groups need to exist in the directory
      Returns:
      result of the bulk operation containing successful and failed entities
      Throws:
      UserNotFoundException - when user with a given username does not exist in the directory with directoryId id

    • addUserToGroup

      public void addUserToGroup(long directoryId, String username, String groupName) throws UserNotFoundException, GroupNotFoundException, MembershipAlreadyExistsException
      Description copied from interface: MembershipDao
      Adds user as a member of group.
      Specified by:
      addUserToGroup in interface MembershipDao
      Parameters:
      directoryId - the directory to perform the operation
      username - user
      groupName - group
      Throws:
      UserNotFoundException - if the user does not exist
      GroupNotFoundException - if the group does not exist
      MembershipAlreadyExistsException - if the user is already a direct member of the group

    • findAll

      public List<InternalMembership> findAll(Collection<Directory> directories)
      Parameters:
      directories - directories to search for memberships
      Returns:
      all memberships across all directories (used for export).

    • findAllLocal

      public List<InternalMembership> findAllLocal(Collection<Directory> directories)
      Parameters:
      directories - directories to search for memberships
      Returns:
      all memberships across all directories (used for export).

    • getPersistentClass

      public Class<InternalMembership> getPersistentClass()
      Description copied from class: HibernateDao
      All subclasses of HibernateDao must implement this method for HibernateDao.load(Serializable) to work correctly.
      Specified by:
      getPersistentClass in class HibernateDao<InternalMembership>
      Returns:
      the entity class for this DAO

    • isGroupDirectMember

      public boolean isGroupDirectMember(long directoryId, String childGroup, String parentGroup)
      Description copied from interface: MembershipDao
      Determines whether the group is a direct member of the (supposedly) parent group.
      Specified by:
      isGroupDirectMember in interface MembershipDao
      Parameters:
      directoryId - the directory to perform the operation
      childGroup - child group
      parentGroup - parent group
      Returns:
      true if the group is a direct member of the (supposedly) parent group

    • isUserDirectMember

      public boolean isUserDirectMember(long directoryId, String username, String groupName)
      Description copied from interface: MembershipDao
      Determines whether the user is a direct member of the group.
      Specified by:
      isUserDirectMember in interface MembershipDao
      Parameters:
      directoryId - the directory to perform the operation
      username - user
      groupName - group
      Returns:
      true if the user is a direct member of the group

    • removeAllRelationships

      public void removeAllRelationships(long directoryId)
      Description copied from interface: InternalMembershipDao
      Removes all relationships the the given directory identified by directory id.
      Specified by:
      removeAllRelationships in interface InternalMembershipDao
      Parameters:
      directoryId - Directory id.

    • removeAllUserRelationships

      public void removeAllUserRelationships(long directoryId)
      Description copied from interface: InternalMembershipDao
      Removes all user relationships the the given directory identified by directory id.
      Specified by:
      removeAllUserRelationships in interface InternalMembershipDao
      Parameters:
      directoryId - Directory id.

    • removeGroupFromGroup

      public void removeGroupFromGroup(long directoryId, String childGroup, String parentGroup) throws MembershipNotFoundException
      Description copied from interface: MembershipDao
      Removes group from the parent group.
      Specified by:
      removeGroupFromGroup in interface MembershipDao
      Parameters:
      directoryId - the directory to perform the operation
      childGroup - child group
      parentGroup - parent group
      Throws:
      MembershipNotFoundException - if the membership relationship between the child and parent group does not exist

    • removeGroupsFromGroup

      public BatchResult<String> removeGroupsFromGroup(long directoryId, Collection<String> childGroupNames, String groupName) throws GroupNotFoundException
      Description copied from interface: MembershipDao
      Bulk remove all the given child groups from the given group. Child groups that are not direct members of the group are reported as failures. childGroupNames that cannot be found in the database are also reported as failures. Implementations must make sure that changes in bulk methods such as this are immediately visible to other bulk methods. For example, if this is run in a transaction, either that transaction must be committed when this method returns, or all other bulk method implementations must guarantee to reuse the same transaction.
      Specified by:
      removeGroupsFromGroup in interface MembershipDao
      Parameters:
      directoryId - the directory to perform the operation
      childGroupNames - the collection of child groups
      groupName - name of the parent group
      Returns:
      result containing both successful (membership successfully removed) and failed groups (unknown childGroupName, or no existing membership)
      Throws:
      GroupNotFoundException - if the parent group does not exist

    • removeGroupMembers

      public void removeGroupMembers(long directoryId, String groupName)
      Description copied from interface: InternalMembershipDao
      Removes all members of the given group name.
      Specified by:
      removeGroupMembers in interface InternalMembershipDao
      Parameters:
      directoryId - Directory id.
      groupName - Group name.

    • removeGroupMemberships

      public void removeGroupMemberships(long directoryId, String groupName)
      Description copied from interface: InternalMembershipDao
      Removes all relationships from parent groups to the given group name.
      Specified by:
      removeGroupMemberships in interface InternalMembershipDao
      Parameters:
      directoryId - Directory id.
      groupName - Group name.

    • removeUserFromGroup

      public void removeUserFromGroup(long directoryId, String username, String groupName) throws UserNotFoundException, GroupNotFoundException, MembershipNotFoundException
      Description copied from interface: MembershipDao
      Removes user as a member of the given group.
      Specified by:
      removeUserFromGroup in interface MembershipDao
      Parameters:
      directoryId - the directory to perform the operation
      username - user
      groupName - group
      Throws:
      UserNotFoundException - if the user does not exist
      GroupNotFoundException - if the group does not exist
      MembershipNotFoundException - if the user is not a member of the said group

    • removeUsersFromGroup

      public BatchResult<String> removeUsersFromGroup(long directoryId, Collection<String> usernames, String groupName) throws GroupNotFoundException
      Description copied from interface: MembershipDao
      Bulk remove all the given users into the given group. Users that are not direct members of the group are reported as failures. Usernames that cannot be found in the database are also reported as failures. Implementations must make sure that changes in bulk methods such as this are immediately visible to other bulk methods. For example, if this is run in a transaction, either that transaction must be committed when this method returns, or all other bulk method implementations must guarantee to reuse the same transaction.
      Specified by:
      removeUsersFromGroup in interface MembershipDao
      Parameters:
      directoryId - the directory to perform the operation
      usernames - the collection of users
      groupName - name of the group
      Returns:
      result containing both successful (membership successfully removed) and failed users (unknown username, or no existing membership)
      Throws:
      GroupNotFoundException - if the group does not exist

    • removeUserMemberships

      public void removeUserMemberships(long directoryId, String username)
      Description copied from interface: InternalMembershipDao
      Removes all MembershipType.GROUP_USER relationships from parent groups to the given username.
      Specified by:
      removeUserMemberships in interface InternalMembershipDao
      Parameters:
      directoryId - Directory id.
      username - Username.

    • renameGroupRelationships

      public void renameGroupRelationships(long directoryId, String oldName, String newName)
      Description copied from interface: InternalMembershipDao
      Renames group name in all relationships.
      Specified by:
      renameGroupRelationships in interface InternalMembershipDao
      Parameters:
      directoryId - Directory id.
      oldName - Old group name.
      newName - New group name.

    • renameUserRelationships

      public void renameUserRelationships(long directoryId, String oldName, String newName)
      Description copied from interface: InternalMembershipDao
      Renames username in all relationships.
      Specified by:
      renameUserRelationships in interface InternalMembershipDao
      Parameters:
      directoryId - Directory id.
      oldName - Old username.
      newName - New username.

    • countDirectMembersOfGroup

      public BoundedCount countDirectMembersOfGroup(long directoryId, String groupName, int potentialMaxCount)
      Description copied from interface: MembershipDao

      Count the direct members of a group with a recommended upper bound on the count.

      The upper bound is there so that, in directories that do not support efficient counting of memberships, less work may be performed.

      Important: Please note that any directory wishing to implement this method should make it as efficient as possible. Such that an administrator could land on a page that showed ~20 groups, run this method once per group, and it would still return results as efficiently as possible.

      Specified by:
      countDirectMembersOfGroup in interface MembershipDao
      Parameters:
      directoryId - the directory to perform the operation
      groupName - the name of the group to search for
      potentialMaxCount - a suggested minimum number of elements for the implementation to count. The implementation will only use this number if it can get efficiency benefits; otherwise this number may be ignored.
      Returns:
      A bounded count of the number of memberships in the given group for the provided directory. If the group does not exist then BoundedCount.exactly(long) 0 will be returned.

    • search

      public <T> List<T> search(long directoryId, MembershipQuery<T> query)
      Description copied from interface: MembershipDao
      Search for memberships by the given criteria.
      Specified by:
      search in interface MembershipDao
      Parameters:
      directoryId - the directory to perform the operation
      query - criteria
      Returns:
      List (can be empty but never null) of memberships which match the given criteria. Results are ordered by entity name, case-insensitive.

    • searchGroupedByName

      public <T> Map<String,List<T>> searchGroupedByName(long directoryId, MembershipQuery<T> query)
      Description copied from interface: MembershipDao
      Search for memberships by the given criteria. Groups results by MembershipQuery.getEntityNamesToMatch().
      Specified by:
      searchGroupedByName in interface MembershipDao
      Parameters:
      directoryId - the directory to perform the operation
      query - criteria
      Returns:
      List (can be empty but never null) of memberships which match the given criteria. Results are ordered by entity name, case-insensitive.

    • setGroupDao

      @Autowired public void setGroupDao(InternalGroupDao groupDao)

    • setHqlQueryTranslater

      @Autowired public void setHqlQueryTranslater(HQLQueryTranslater hqlQueryTranslater)

    • setUserDao

      @Autowired public void setUserDao(InternalUserDao userDao)

    • setAuditProcessor

      @Autowired public void setAuditProcessor(@Qualifier("membershipAuditProcessor") MembershipAuditProcessor auditProcessor)