znyc.dispatching.api/src/Znyc.Dispatching.Application/Employee/Services/EmployeeService.cs

using Furion.DatabaseAccessor;
using Furion.DependencyInjection;
using Furion.DynamicApiController;
using Furion.FriendlyException;
using Mapster;
using Microsoft.AspNetCore.Mvc;
using Microsoft.EntityFrameworkCore;
using Microsoft.Extensions.Options;
using System.Collections.Generic;
using System.ComponentModel.DataAnnotations;
using System.Linq;
using System.Threading.Tasks;
using Znyc.Dispatching.Common.Extensions;
using Znyc.Dispatching.Core;
using Znyc.Dispatching.Core.Entitys;
using Znyc.Dispatching.Core.Extension;
using Znyc.Dispatching.Core.Helpers;

namespace Znyc.Dispatching.Application
{
    /// <summary>
    ///     员工服务
    /// </summary>
    [ApiDescriptionSettings(Name = "employee", Order = 20)]
    public class EmployeeService : IEmployeeService, IDynamicApiController, ITransient
    {
        private string[] INDEX_STRINGS = {"A", "B", "C", "D", "E", "F", "G", "H", "I",
            "J", "K", "L", "M", "N", "O", "P", "Q", "R", "S", "T", "U", "V",
            "W", "X", "Y", "Z", "#"};

        private string[] ROLEINDEX_STRINGS = { "C", "D", "J", "G", "W", "Y", "X", "#" };


        private readonly ICacheService _cacheService;
        private readonly IRepository<Employee> _repository;
        private readonly IRepository<User> _userRepository;
        private readonly IRepository<UserRole> _userRoleRepository;
        private readonly IRepository<Company> _companyRepository;
        private readonly IUserManager _userManager;
        private readonly IRepository<VehiclePerson> _vehiclePersonRepository;
        private readonly IRepository<ProjectPerson> _projectPersonRepository;


        public EmployeeService(
            IRepository<Employee> repository,
            IRepository<User> userRepository,
            IRepository<Company> companyRepository,
            IUserManager userManager,
            ICacheService cacheService,
            IRepository<UserRole> userRoleRepository,
            IOptions<SmsProviderOptions> smsProviderOptions,
            IRepository<VehiclePerson> vehiclePersonRepository,
            IRepository<ProjectPerson> projectPersonRepository
        )
        {
            _repository = repository;
            _userRepository = userRepository;
            _companyRepository = companyRepository;
            _userManager = userManager;
            _cacheService = cacheService;
            _userRoleRepository = userRoleRepository;
            _vehiclePersonRepository = vehiclePersonRepository;
            _projectPersonRepository = projectPersonRepository;
        }

        /// <summary>
        ///     员工信息
        /// </summary>
        /// <param name="currentPage"></param>
        /// <param name="pageSize"></param>
        /// <param name="roleId"></param>
        /// <param name="status">0全部,停用-1,正常1</param>
        /// <param name="key"></param>
        /// <param name="orderby"></param>
        /// <returns></returns>
        [HttpGet]
        [Route("api/v1/employees/search")]
        public async Task<EmployeeListPage> PageAsync([Required] int currentPage, [Required] int pageSize, [FromQuery] int status, [Required] int roleId, [FromQuery] string orderby, [FromQuery] string key = "")
        {

            var employees = (await _cacheService.GetEmployeeListAsync(_userManager.CompanyId))
                .WhereIf(status != 0, x => x.Status == status)
                .WhereIf(roleId > 0, x => x.RoleId == roleId)
                .WhereIf(new long[] { (long)RoleStatusEnum.Scheduling, (long)RoleStatusEnum.CarCaptain }.Contains(_userManager.RoleId),
                    x => new long[] { (long)RoleStatusEnum.CrewMembers, (long)RoleStatusEnum.Outside,
                        (long)RoleStatusEnum.PartTimeSalesman,(long)RoleStatusEnum.Salesman }.Contains(x.RoleId))
                .WhereIf(key.IsNotEmptyOrNull(), x => x.EmployeeName.Contains(key) || x.EmployeePhone.Contains(key))
                .Adapt<List<EmployeeListOutput>>();
            var employeeOutputs = new List<EmployeeListOutputs>();

            if (orderby == "role")
            {
                employees = employees.OrderBy(x => x.RoleName).ToList();
                foreach (var INDEX_STRING in ROLEINDEX_STRINGS)
                {
                    employeeOutputs.Add(new EmployeeListOutputs()
                    {
                        Char = INDEX_STRING,
                        List = employees.Where(x => StringHelper.GetStringFirstSpell(x.RoleName) == INDEX_STRING).ToList()
                    });
                };
            }
            else
            {
                employees = employees.OrderBy(x => x.EmployeeName).ToList();

                foreach (var INDEX_STRING in INDEX_STRINGS)
                {
                    employeeOutputs.Add(new EmployeeListOutputs()
                    {
                        Char = INDEX_STRING,
                        List = employees.Where(x => StringHelper.GetStringFirstSpell(x.EmployeeName) == INDEX_STRING).ToList()
                    });
                };
            }
            var data = new EmployeeListPage()
            {
                EmployeeList = employeeOutputs,
                Total = employees.Count
            };
            return data;
        }

        /// <summary>
        ///     根据id获取员工资料
        /// </summary>
        /// <returns></returns>
        [HttpGet]
        [Route("api/v1/employee/{id}")]
        public async Task<EmployeeOutput> GetByIdAsync(long id)
        {
            return await _cacheService.GetEmployeeAsync(id);
        }

        /// <summary>
        ///     添加员工信息
        /// </summary>
        /// <param name="employeeAdd"></param>
        /// <returns></returns>
        [HttpPost]
        [UnitOfWork]
        [NonAction]
        //[Route("api/v1/employee")]
        public async Task<long> AddAsync(EmployeeAddInput employeeAdd)
        {
            var user = await _userRepository.Where(x => x.Phone == employeeAdd.EmployeePhone).FirstOrDefaultAsync();
            if (user.IsNotNull())
            {
                return user.Id;
            }

            var company = await _companyRepository.FindOrDefaultAsync(_userManager.CompanyId);
            if (company.IsNotNull())
            {
                //用户
                var userEntity = await _userRepository.InsertNowAsync(new User
                {
                    OpenId = "",
                    UserName = employeeAdd.EmployeeName,
                    AvatarUrl = CommonConst.DEFAULT_AVATARURL_ALL,
                    Phone = employeeAdd.EmployeePhone,
                    Status = CommonStatusEnum.ENABLE
                });
                //员工
                var employee = await _repository.InsertNowAsync(new Employee
                {
                    UserId = userEntity.Entity.Id,
                    AvatarUrl = CommonConst.DEFAULT_AVATARURL,
                    EmployeeName = employeeAdd.EmployeeName,
                    EmployeePhone = employeeAdd.EmployeePhone,
                    CompanyId = company.Id,
                    RoleId = employeeAdd.RoleId,
                    RoleName = employeeAdd.RoleName,
                    IsDefault = true,
                    Status = (int)CommonStatusEnum.ENABLE
                });
                //用户角色
                await _userRoleRepository.InsertNowAsync(new UserRole
                {
                    UserId = userEntity.Entity.Id,
                    RoleId = employeeAdd.RoleId,
                });
                //清除员工列表Cache
                await _cacheService.RemoveEmployeeListAsync(_userManager.CompanyId);
                return employee.Entity.UserId;
            }
            else
            {
                return 0;
            }
        }

        /// <summary>
        ///     编辑员工信息
        /// </summary>
        /// <returns></returns>
        [HttpPut]
        [UnitOfWork]
        [Route("api/v1/employee")]
        public async Task UpdateAsync(EmployeeUpdateInput input)
        {
            var employee = await _repository.FindOrDefaultAsync(input.Id);
            //权限变动,清除对应缓存
            if (!employee.RoleId.Equals(input.RoleId))
            {
                await _cacheService.RemoveTokenAsync(employee.UserId);
            }
            employee = input.Adapt(employee);
            employee.AvatarUrl = CommonConst.Prefix_AvataUrl + employee.AvatarUrl[(employee.AvatarUrl.LastIndexOf("/") + 1)..];
            var result = await _repository.UpdateNowAsync(employee);
            if (result.IsNull())
            {
                throw Oops.Oh("更新员工信息失败");
            }
            //同步更新user
            var user = await _userRepository.FirstOrDefaultAsync(x => x.Id == employee.UserId);
            if (user.IsNotNull())
            {
                user.UserName = input.EmployeeName;
                user.Phone = input.EmployeePhone;
                user.AvatarUrl = employee.AvatarUrl;
                await _userRepository.UpdateNowAsync(user);
                await _cacheService.RemoveUserAsync(user.Id);
            }

            //更新当前用户下所有角色姓名
            var employees = await _repository.Where(x => x.UserId == user.Id).ToListAsync();
            foreach (var employee2 in employees)
            {
                if (employee.IsNotNull())
                {
                    employee.EmployeePhone = input.EmployeePhone;
                    employee.EmployeeName = input.EmployeeName;
                    employee.AvatarUrl = CommonConst.Prefix_AvataUrl + input.AvatarUrl[(input.AvatarUrl.LastIndexOf("/") + 1)..];
                    await _repository.UpdateNowAsync(employee2);
                    await _cacheService.RemoveEmployeeAsync(employee2.Id);
                    await _cacheService.RemoveEmployeeListAsync(employee2.CompanyId);
                }
            }


            //清除员工Cache
            await _cacheService.RemoveEmployeeAsync(employee.Id);
            //清除用户Cache
            await _cacheService.RemoveUserAsync(employee.UserId);
            //清除员工列表Cache
            await _cacheService.RemoveEmployeeListAsync(_userManager.CompanyId);
            //同步车组人员表
            var vehiclePersons = await _vehiclePersonRepository.Where(x => x.IsDeleted == false && x.UserId == user.Id).ToListAsync();
            foreach (var item in vehiclePersons)
            {
                //解除车组人员关联
                if (input.Status == (int)CommonStatusEnum.DISABLE)
                {
                    item.IsDeleted = true;
                }
                item.UserName = input.EmployeeName;
                item.UserPhone = input.EmployeePhone;
                await _vehiclePersonRepository.UpdateNowAsync(item);
                //删除车组人员Cache
                await _cacheService.RemoveVehiclePersonAsync(item.VehicleId);
            }
            //同步工程联系人表
            var projectPersons = await _projectPersonRepository.Where(x => x.IsDeleted == false && x.ProjectPersonId == user.Id).ToListAsync();
            foreach (var item in projectPersons)
            {
                item.ProjectPersonName = input.EmployeeName;
                item.ProjectPersonPhone = input.EmployeePhone;
                await _projectPersonRepository.UpdateNowAsync(item);
                //清除工程信息Cache
                await _cacheService.RemoveProjectAsync(item.ProjectId);
                //清除工程列表信息Cache
                await _cacheService.RemoveProjectListAsync(_userManager.CompanyId);
            }
            //同步用户角色表
            //var userRole = await _userRoleRepository.FirstOrDefaultAsync(x => x.UserId == employee.UserId);
            //userRole.RoleId = employee.RoleId;
            //await _userRoleRepository.UpdateNowAsync(userRole);
           
        }


        /// <summary>
        ///     软删除员工信息
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        [HttpDelete]
        [Route("api/v1/employee")]

        public async Task DeleteByIdAsync(long id)
        {
            Employee employee = await _repository
                .FirstOrDefaultAsync(x => x.Id == id && x.CompanyId == _userManager.CompanyId);
            employee.IsDeleted = true;
            await _repository.UpdateNowAsync(employee);
            await _cacheService.RemoveCacheByUserIdAsync(employee.UserId);
            await _cacheService.RemoveEmployeeAsync(employee.Id);
            await _cacheService.RemoveEmployeeListAsync(_userManager.CompanyId);
            await _cacheService.RemoveUserAsync(employee.UserId);
        }


    }
}