IM_NEW/GroupService.WebApi/Application/Group/GroupService.cs

using AutoMapper;
using GroupService.Domain.IReposities;
using GroupService.WebApi.Application.Dtos;
using IM.Commons;

namespace GroupService.WebApi.Application.Group
{
    public class GroupService
    {
        private readonly IGroupReposity reposity;
        private readonly IGroupMemberReposity memberReposity;
        private readonly IMapper mapper;

        public GroupService(IGroupReposity reposity, IGroupMemberReposity memberReposity, IMapper mapper)
        {
            this.reposity = reposity;
            this.memberReposity = memberReposity;
            this.mapper = mapper;
        }

        public async Task<Result<GroupResponse>> CreateAsync(GroupCreateCommand command)
        {
            var group = new Domain.Entities.Group(command.GroupMasterId, command.Name);
            reposity.Create(group);
            return Result<GroupResponse>.Success(mapper.Map<GroupResponse>(group));
        }

        public async Task<Result<List<GroupResponse>>> GetAllAsync(Guid userId)
        {
            var groups = await reposity.FindByMemberIdAsync(userId);
            return Result<List<GroupResponse>>.Success(mapper.Map<List<GroupResponse>>(groups));
        }

        public async Task<Result<GroupResponse>> GetByIdAsync(Guid groupId, Guid userId)
        {
            var group = await reposity.FindByIdAsync(groupId);
            if (group is null)
            {
                return Result<GroupResponse>.Fail(ResultCode.GROUP_NOT_FOUND);
            }

            if (!await memberReposity.CheckMemberExistAsync(groupId, userId))
            {
                return Result<GroupResponse>.Fail(ResultCode.PERMISSION_DENIED);
            }

            return Result<GroupResponse>.Success(mapper.Map<GroupResponse>(group));
        }

        public async Task<Result<object>> DissolveAsync(Guid groupId, Guid userId)
        {
            var group = await reposity.FindByIdAsync(groupId);
            if (group is null)
            {
                return Result.Fail(ResultCode.GROUP_NOT_FOUND);
            }

            if (group.GroupMaster != userId)
            {
                return Result.Fail(ResultCode.PERMISSION_DENIED);
            }

            var members = await memberReposity.FindByGroupIdAsync(groupId);
            foreach (var member in members)
            {
                member.Leave();
            }
            group.SoftDelete();
            return Result.Success();
        }

        public async Task<Result<GroupResponse>> UpdateAsync(GroupUpdateCommand command)
        {
            var group = await reposity.FindByIdAsync(command.GroupId);
            if(group is null)
                return Result.Fail<GroupResponse>(ResultCode.GROUP_NOT_FOUND);

            var isAdmin = await memberReposity.CheckMemberAdminAsync(group.Id ,command.UserId);
            if (!isAdmin)
                return Result.Fail<GroupResponse>(ResultCode.ADMIN_PERMISSION_DENIED);

            group.Update(command.GroupName, null, command.Description, command.Avatar);
            return Result.Success(mapper.Map<GroupResponse>(group));
        }
    }
}