Example #1
0
        public Result <EmptyResult> DisassociateOrganizationUserFromGroup(DisassociateOrganizationUserFromGroupCommand command)
        {
            if (command.OrganizationId <= 0)
            {
                return(new Result <EmptyResult>(GroupServiceErrors.InvalidDisassociateOrganizationUserFromGroupDataError(nameof(command.OrganizationId))));
            }

            if (command.GroupId <= 0)
            {
                return(new Result <EmptyResult>(GroupServiceErrors.InvalidDisassociateOrganizationUserFromGroupDataError(nameof(command.GroupId))));
            }

            if (!groupRepository.GroupExists(command.GroupId, command.OrganizationId))
            {
                return(new Result <EmptyResult>(GroupServiceErrors.GroupNotFoundError()));
            }

            if (!organizationUserRepository.OrganizationUserExists(command.OrganizationUserId, command.OrganizationId))
            {
                return(new Result <EmptyResult>(GroupServiceErrors.OrganizationUserNotFoundError()));
            }

            var result = groupRepository.DisassociateOrganizationUserFromGroup(command);

            if (!result)
            {
                return(new Result <EmptyResult>(GroupServiceErrors.InvalidDisassociateOrganizationUserFromGroupDataError()));
            }

            return(new Result <EmptyResult>());
        }
Example #2
0
        public Result <EmptyResult> AssociateOrganizationUserToGroup(AssociateOrganizationUserToGroupCommand command)
        {
            if (command.OrganizationId <= 0)
            {
                return(new Result <EmptyResult>(GroupServiceErrors.InvalidAssociateOrganizationUserToGroupDataError(nameof(command.OrganizationId))));
            }

            if (command.GroupId <= 0)
            {
                return(new Result <EmptyResult>(GroupServiceErrors.InvalidAssociateOrganizationUserToGroupDataError(nameof(command.GroupId))));
            }

            if (!groupRepository.GroupExists(command.GroupId, command.OrganizationId))
            {
                return(new Result <EmptyResult>(GroupServiceErrors.GroupNotFoundError()));
            }

            if (groupRepository.OrganizationUserAssociationWithGroupExists(command.GroupId, command.OrganizationUserId, command.OrganizationId))
            {
                return(new Result <EmptyResult>(GroupServiceErrors.AssociationAlreadyExistsError()));
            }

            // want to check allowed user types to prevent non authorized user-types being added to a group
            var orgUserType = organizationUserRepository.GetOrganizationUserType(command.OrganizationUserId, command.OrganizationId);

            if (!orgUserType.HasValue || !command.AllowedUserTypes.Contains(orgUserType.Value))
            {
                return(new Result <EmptyResult>(GroupServiceErrors.OrganizationUserNotFoundError()));
            }

            groupRepository.AssociateOrganizationUserToGroup(command);

            return(new Result <EmptyResult>());
        }
Example #3
0
        public Result <EmptyResult> UpdateGroup(UpdateGroupCommand command)
        {
            if (command.OrganizationId <= 0)
            {
                return(new Result <EmptyResult>(GroupServiceErrors.InvalidUpdateGroupDataError(nameof(command.OrganizationId))));
            }

            if (command.GroupId <= 0)
            {
                return(new Result <EmptyResult>(GroupServiceErrors.InvalidUpdateGroupDataError(nameof(command.GroupId))));
            }

            if (!groupRepository.GroupExists(command.GroupId, command.OrganizationId))
            {
                return(new Result <EmptyResult>(GroupServiceErrors.GroupNotFoundError()));
            }

            if (groupRepository.GroupNameExists(command.GroupId, command.Name, command.OrganizationId))
            {
                return(new Result <EmptyResult>(GroupServiceErrors.GroupAlreadyExistsError()));
            }

            groupRepository.UpdateGroup(command);

            return(new Result <EmptyResult>());
        }
Example #4
0
        public Result <QueryGroupResult> QueryGroups(int organizationId)
        {
            if (organizationId <= 0)
            {
                return(new Result <QueryGroupResult>(GroupServiceErrors.InvalidQueryGroupsDataError(nameof(organizationId))));
            }

            var result = groupRepository.QueryGroups(organizationId, true);

            return(new Result <QueryGroupResult>(result));
        }
Example #5
0
        public Result <QueryMemberGroupResult> QueryMemberGroup(QueryMemberGroupCriteria criteria)
        {
            if (criteria.MemberId <= 0)
            {
                return(new Result <QueryMemberGroupResult>(GroupServiceErrors.InvalidQueryMemberGroupDataError(nameof(criteria.MemberId))));
            }

            if (criteria.OrganizationId <= 0)
            {
                return(new Result <QueryMemberGroupResult>(GroupServiceErrors.InvalidQueryMemberGroupDataError(nameof(criteria.OrganizationId))));
            }
            var result = groupRepository.QueryMemberGroup(criteria);

            return(new Result <QueryMemberGroupResult>(result));
        }
Example #6
0
        public Result <bool> ExistGroupByName(string name, int organizationId)
        {
            if (string.IsNullOrWhiteSpace(name))
            {
                return(new Result <bool>(GroupServiceErrors.InvalidGroupNameError()));
            }

            if (organizationId <= 0)
            {
                return(new Result <bool>(GroupServiceErrors.InvalidOrganizationIdError()));
            }

            var result = groupRepository.ExistGroupByName(name, organizationId);

            return(new Result <bool>(result));
        }
Example #7
0
        public Result <EmptyResult> DeleteGroup(DeleteGroupCommand command)
        {
            if (command.OrganizationId <= 0)
            {
                return(new Result <EmptyResult>(GroupServiceErrors.InvalidDeleteGroupDataError(nameof(command.OrganizationId))));
            }

            if (command.GroupId <= 0)
            {
                return(new Result <EmptyResult>(GroupServiceErrors.InvalidDeleteGroupDataError(nameof(command.GroupId))));
            }

            if (!groupRepository.GroupExists(command.GroupId, command.OrganizationId))
            {
                return(new Result <EmptyResult>(GroupServiceErrors.GroupNotFoundError()));
            }

            groupRepository.DeleteGroup(command);

            return(new Result <EmptyResult>());
        }
Example #8
0
        public Result <QueryGroupMemberResult> QueryGroupMember(QueryGroupMemberCriteria criteria)
        {
            if (criteria.GroupId <= 0)
            {
                return(new Result <QueryGroupMemberResult>(GroupServiceErrors.InvalidQueryGroupMemberDataError(nameof(criteria.GroupId))));
            }

            if (criteria.OrganizationId <= 0)
            {
                return(new Result <QueryGroupMemberResult>(GroupServiceErrors.InvalidQueryGroupMemberDataError(nameof(criteria.OrganizationId))));
            }
            if (!groupRepository.GroupExists(criteria.GroupId, criteria.OrganizationId))
            {
                return(new Result <QueryGroupMemberResult>(GroupServiceErrors.GroupNotFoundError()));
            }
            if (criteria.Page == null || criteria.Page.Value <= 0)
            {
                criteria.Page = 1;
            }

            if (criteria.PageSize == null || criteria.PageSize.Value <= 0)
            {
                criteria.PageSize = 10;
            }

            string[] sortableFields = groupRepository.GetGroupMemberSortableFields();
            if (!sortableFields.Contains(criteria.OrderBy, StringComparer.OrdinalIgnoreCase))
            {
                criteria.OrderBy = groupRepository.GetDefaultSortField();
            }

            if (!string.Equals(criteria.Direction, "DESC", StringComparison.OrdinalIgnoreCase))
            {
                criteria.Direction = "ASC";
            }
            var queryGroupMemberResult = groupRepository.QueryGroupMember(criteria);

            return(new Result <QueryGroupMemberResult>(queryGroupMemberResult));
        }
Example #9
0
        public Result <int> CreateGroup(CreateGroupCommand command)
        {
            if (command.OrganizationId <= 0)
            {
                return(new Result <int>(GroupServiceErrors.InvalidCreateGroupDataError(nameof(command.OrganizationId))));
            }

            if (command.ParentGroupId <= 0)
            {
                return(new Result <int>(GroupServiceErrors.InvalidCreateGroupDataError(nameof(command.ParentGroupId))));
            }

            if (string.IsNullOrWhiteSpace(command.Name))
            {
                return(new Result <int>(GroupServiceErrors.InvalidCreateGroupDataError(nameof(command.Name))));
            }

            if (groupRepository.GroupExists(command.Name, command.OrganizationId))
            {
                return(new Result <int>(GroupServiceErrors.GroupAlreadyExistsError()));
            }

            return(new Result <int>(this.groupRepository.CreateGroup(command)));
        }