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

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

namespace GroupService.WebApi.Application.Group
{
    public class GroupService
    {
        private readonly IGroupReposity reposity;
        private readonly IGroupMemberReposity memberReposity;
        private readonly IMapper mapper; private readonly IM.InitCommon.Management.RuntimePolicy runtime; private readonly global::GroupService.Infrastructure.GroupDbContext db;

        public GroupService(IGroupReposity reposity, IGroupMemberReposity memberReposity, IMapper mapper, IM.InitCommon.Management.RuntimePolicy runtime, global::GroupService.Infrastructure.GroupDbContext db)
        {
            this.reposity = reposity;
            this.memberReposity = memberReposity;
            this.mapper = mapper; this.runtime = runtime; this.db = db;
        }

        public async Task<Result<GroupResponse>> CreateAsync(GroupCreateCommand command)
        {
            var policy = runtime.Current;
            if (policy.CreatedGroupLimit > 0 && await db.Groups.CountAsync(x => x.GroupMaster == command.GroupMasterId) >= policy.CreatedGroupLimit)
                return Result.Fail<GroupResponse>(ResultCode.PERMISSION_DENIED, "创建群组数量已达到平台上限");
            var group = new Domain.Entities.Group(command.GroupMasterId, command.Name);
            group.Update(null, (Domain.Enums.GroupAuthorityType)policy.DefaultJoinAuthority, null, null);
            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));
        }
    }
}