99ditui/src/plates/ZhonTai.Plate.Personal/ZhonTai.Plate.Personnel.Service/Employee/EmployeeService.cs

using System.Linq;
using System.Threading.Tasks;
using ZhonTai.Common.Attributes;
using ZhonTai.Common.Domain.Dto;
using ZhonTai.Plate.Personnel.Domain;
using ZhonTai.Plate.Personnel.Service.Employee.Input;
using ZhonTai.Plate.Personnel.Service.Employee.Output;
using ZhonTai.Plate.Admin.Service;
using ZhonTai.Common.Domain.Repositories;
using ZhonTai.Plate.Personnel.Domain.Employee;
using ZhonTai.Plate.Personnel.Domain.Organization;

namespace ZhonTai.Plate.Personnel.Service.Employee
{
    /// <summary>
    /// 员工服务
    /// </summary>
    public class EmployeeService : BaseService, IEmployeeService
    {
        private readonly IEmployeeRepository _employeeRepository;
        private readonly IRepositoryBase<EmployeeOrganizationEntity> _employeeOrganizationRepository;

        public EmployeeService(
            IEmployeeRepository userRepository,
            IRepositoryBase<EmployeeOrganizationEntity> employeeOrganizationRepository
        )
        {
            _employeeRepository = userRepository;
            _employeeOrganizationRepository = employeeOrganizationRepository;
        }

        public async Task<ResultOutput<EmployeeGetOutput>> GetAsync(long id)
        {
            var res = new ResultOutput<EmployeeGetOutput>();

            var dto = await _employeeRepository.Select
            .WhereDynamic(id)
            .IncludeMany(a => a.Organizations.Select(b => new OrganizationEntity { Id = b.Id }))
            .ToOneAsync(a => new EmployeeGetOutput
            {
                OrganizationName = a.Organization.Name,
                PositionName = a.Position.Name
            });

            return res.Ok(dto);
        }

        public async Task<IResultOutput> GetPageAsync(PageInput<EmployeeEntity> input)
        {
            var list = await _employeeRepository.Select
            .WhereDynamicFilter(input.DynamicFilter)
            .Count(out var total)
            .OrderByDescending(true, a => a.Id)
            .IncludeMany(a => a.Organizations.Select(b => new OrganizationEntity { Name = b.Name }))
            .Page(input.CurrentPage, input.PageSize)
            .ToListAsync(a => new EmployeeListOutput 
            { 
                OrganizationName = a.Organization.Name, 
                PositionName = a.Position.Name
            });

            var data = new PageOutput<EmployeeListOutput>()
            {
                List = list,
                Total = total
            };

            return ResultOutput.Ok(data);
        }

        [Transaction]
        public async Task<IResultOutput> AddAsync(EmployeeAddInput input)
        {
            var entity = Mapper.Map<EmployeeEntity>(input);
            var employeeId = (await _employeeRepository.InsertAsync(entity))?.Id;

            if (!(employeeId > 0))
            {
                return ResultOutput.NotOk();
            }

            //附属部门
            if (input.OrganizationIds != null && input.OrganizationIds.Any())
            {
                var organizations = input.OrganizationIds.Select(organizationId => new EmployeeOrganizationEntity 
                { 
                    EmployeeId = employeeId.Value, 
                    OrganizationId = organizationId 
                });
                await _employeeOrganizationRepository.InsertAsync(organizations);
            }

            return ResultOutput.Ok();
        }

        [Transaction]
        public async Task<IResultOutput> UpdateAsync(EmployeeUpdateInput input)
        {
            if (!(input?.Id > 0))
            {
                return ResultOutput.NotOk();
            }

            var employee = await _employeeRepository.GetAsync(input.Id);
            if (!(employee?.Id > 0))
            {
                return ResultOutput.NotOk("用户不存在！");
            }

            Mapper.Map(input, employee);
            await _employeeRepository.UpdateAsync(employee);

            await _employeeOrganizationRepository.DeleteAsync(a => a.EmployeeId == employee.Id);

            //附属部门
            if (input.OrganizationIds != null && input.OrganizationIds.Any())
            {
                var organizations = input.OrganizationIds.Select(organizationId => new EmployeeOrganizationEntity 
                { 
                    EmployeeId = employee.Id, 
                    OrganizationId = organizationId 
                });
                await _employeeOrganizationRepository.InsertAsync(organizations);
            }

            return ResultOutput.Ok();
        }

        [Transaction]
        public async Task<IResultOutput> DeleteAsync(long id)
        {
            //删除员工附属部门
            await _employeeOrganizationRepository.DeleteAsync(a => a.EmployeeId == id);

            //删除员工
            await _employeeRepository.DeleteAsync(m => m.Id == id);

            return ResultOutput.Ok();
        }

        public async Task<IResultOutput> SoftDeleteAsync(long id)
        {
            await _employeeRepository.SoftDeleteAsync(id);

            return ResultOutput.Ok();
        }

        public async Task<IResultOutput> BatchSoftDeleteAsync(long[] ids)
        {
            await _employeeRepository.SoftDeleteAsync(ids);

            return ResultOutput.Ok();
        }
    }
}