peis/src/Shentun.Peis.Application/CustomerOrgRegisters/CustomerOrgRegisterAppService.cs

using AutoMapper.Internal.Mappers;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using NPOI.OpenXmlFormats.Dml;
using Shentun.Peis.CustomerOrgRegisters;
using Shentun.Peis.CustomerOrgs;
using Shentun.Peis.HelperDto;
using Shentun.Peis.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Volo.Abp;
using Volo.Abp.Application.Dtos;
using Volo.Abp.Application.Services;
using Volo.Abp.Domain.Repositories;
using Volo.Abp.Identity;
using Volo.Abp.ObjectMapping;

namespace Shentun.Peis.CustomerOrgRegisters
{

    /// <summary>
    /// 单位体检次数
    /// </summary>
    [ApiExplorerSettings(GroupName = "Work")]
    [Authorize]
    public class CustomerOrgRegisterAppService : CrudAppService<
            CustomerOrgRegister, //The Book entity
            CustomerOrgRegisterDto, //Used to show books
            Guid, //Primary key of the book entity
            PagedAndSortedResultRequestDto, //Used for paging/sorting
            CreateCustomerOrgRegisterDto,
            UpdateCustomerOrgRegisterDto>
    {
        private readonly IRepository<IdentityUser, Guid> _userRepository;
        private readonly IRepository<CustomerOrg, Guid> _customerOrgRepository;
        private readonly CustomerOrgManager _customerOrgManager;
        private readonly CustomerOrgRegisterManager _manager;
        private readonly CacheService _cacheService;
        public CustomerOrgRegisterAppService(
            IRepository<CustomerOrgRegister, Guid> repository,
            IRepository<IdentityUser, Guid> userRepository,
             IRepository<CustomerOrg, Guid> customerOrgRepository,
            CustomerOrgManager customerOrgManager,
            CustomerOrgRegisterManager manager,
             CacheService cacheService)
            : base(repository)
        {
            _userRepository = userRepository;
            this._customerOrgRepository = customerOrgRepository;
            this._customerOrgManager = customerOrgManager;
            _manager = manager;
            _cacheService = cacheService;
        }
        /// <summary>
        /// 获取通过主键
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public override async Task<CustomerOrgRegisterDto> GetAsync(Guid id)
        {
            return await base.GetAsync(id);
        }

        /// <summary>
        /// 获取通过主键
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/CustomerOrgRegister/GetById")]
        public async Task<CustomerOrgRegisterDto> GetByIdAsync(CustomerOrgRegisterIdInputDto input)
        {
            return await base.GetAsync(input.CustomerOrgRegisterId);
        }
        /// <summary>
        /// 获取列表  团检体检登记  遗弃
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [RemoteService(false)]
        public override async Task<PagedResultDto<CustomerOrgRegisterDto>> GetListAsync(PagedAndSortedResultRequestDto input)
        {
            return await base.GetListAsync(input);
        }


        /// <summary>
        /// 获取列表  团检体检登记  带搜索计划名称
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        public async Task<List<CustomerOrgRegisterDto>> GetListInFilterAsync(GetListInFilterDto input)
        {
            var entlist = await Repository.GetQueryableAsync();

            if (!string.IsNullOrEmpty(input.Filter))
                entlist = entlist.Where(m => m.RegisterName.Contains(input.Filter));

            var entdto = entlist.Select(s => new CustomerOrgRegisterDto
            {
                CreationTime = s.CreationTime,
                CreatorId = s.CreatorId,
                Id = s.Id,
                LastModificationTime = s.LastModificationTime,
                LastModifierId = s.LastModifierId,
                BeginTime = DataHelper.ConversionDateToString(s.BeginTime),
                EndTime = DataHelper.ConversionDateToString(s.EndTime),
                RegisterName = s.RegisterName,
                RegisterNo = s.RegisterNo,
                MedicalTimes = s.MedicalTimes,
                IsComplete = s.IsComplete,
                CustomerOrgId = s.CustomerOrgId,
                CreatorName = _cacheService.GetSurnameAsync(s.CreatorId).Result,
                LastModifierName = _cacheService.GetSurnameAsync(s.LastModifierId).Result
            }).OrderBy(m => m.CreationTime).ToList();

            return entdto;


        }




        /// <summary>
        /// 新增体检次数 只传单位ID
        /// </summary>
        /// <param name="CustomerOrgId">单位ID</param>
        /// <returns></returns>
        [HttpPost("api/customerorgregister/createcustomerorgregister")]
        public async Task<CustomerOrgRegisterDto> CreateCustomerOrgRegisterAsync(Guid CustomerOrgId)
        {
            var customerOrg = await _customerOrgRepository.GetAsync(CustomerOrgId);
            var pathCode = customerOrg.PathCode.Substring(0, 5);
            var topParentCustomerOrg = await _customerOrgRepository.GetAsync(o => o.PathCode == pathCode);
            var CustomerOrgParenId = topParentCustomerOrg.Id;  //获取一级单位ID

            var entity = await _manager.CreateAsync(CustomerOrgParenId);
            entity = await Repository.InsertAsync(entity);
            var dto = ObjectMapper.Map<CustomerOrgRegister, CustomerOrgRegisterDto>(entity);
            return dto;
        }



        /// <summary>
        /// 更新 是否完成状态
        /// </summary>
        /// <param name="id"></param>
        /// <param name="IsComplete">是否完成（Y N）</param>
        /// <returns></returns>
        public async Task<CustomerOrgRegisterDto> UpdateStateAsync(Guid id, char IsComplete)
        {
            var entity = await _manager.UpdateStateAsync(id, IsComplete);
            return ObjectMapper.Map<CustomerOrgRegister, CustomerOrgRegisterDto>(entity);
        }


        /// <summary>
        /// 更新  不需要使用
        /// </summary>
        /// <param name="id"></param>
        /// <param name="input"></param>
        /// <returns></returns>
        [RemoteService(false)]
        public override async Task<CustomerOrgRegisterDto> UpdateAsync(Guid id, UpdateCustomerOrgRegisterDto input)
        {
            //var entity = await Repository.GetAsync(id);
            //var sourceEntity = ObjectMapper.Map<UpdateCustomerOrgRegisterDto, CustomerOrgRegister>(input);
            //_manager.UpdateAsync(sourceEntity, entity);
            //entity = await Repository.UpdateAsync(entity);
            //return ObjectMapper.Map<CustomerOrgRegister, CustomerOrgRegisterDto>(entity);
            return await base.UpdateAsync(id, input);
        }
        /// <summary>
        /// 删除
        /// </summary>
        /// <param name="id"></param>
        /// <returns></returns>
        public override async Task DeleteAsync(Guid id)
        {
            await _manager.CheckAndDeleteAsync(id);
        }

        /// <summary>
        /// 获取团检体检登记列表，根据单位ID过滤查询
        /// </summary>
        /// <param name="CustomerOrgId"></param>
        /// <returns></returns>
        [HttpGet("api/app/customerorgregister/getlistincustomerorgid")]
        public async Task<List<CustomerOrgRegisterDto>> GetListInCustomerOrgIdAsync(Guid CustomerOrgId)
        {

            #region 查找一级单位

            var customerOrgEnt = await _customerOrgRepository.FirstOrDefaultAsync(f => f.Id == CustomerOrgId);
            if (customerOrgEnt != null && customerOrgEnt.ParentId != null && customerOrgEnt.PathCode.Length > 5)
            {
                string topPathCode = customerOrgEnt.PathCode.Substring(0, 5);
                customerOrgEnt = await _customerOrgRepository.FirstOrDefaultAsync(f => f.PathCode == topPathCode);
                if (customerOrgEnt != null)
                {
                    CustomerOrgId = customerOrgEnt.Id;
                }
            }

            #endregion

 
            var entlist = (await Repository.GetQueryableAsync()).Where(m => m.CustomerOrgId == CustomerOrgId).ToList();


            var entdto = entlist.Select(s => new CustomerOrgRegisterDto
            {
                CreationTime = s.CreationTime,
                CreatorId = s.CreatorId,
                Id = s.Id,
                LastModificationTime = s.LastModificationTime,
                LastModifierId = s.LastModifierId,
                BeginTime = DataHelper.ConversionDateToString(s.BeginTime),
                EndTime = DataHelper.ConversionDateToString(s.EndTime),
                RegisterName = s.RegisterName,
                RegisterNo = s.RegisterNo,
                MedicalTimes = s.MedicalTimes,
                IsComplete = s.IsComplete,
                CustomerOrgId = s.CustomerOrgId,
                CreatorName = _cacheService.GetSurnameAsync(s.CreatorId).Result,
                LastModifierName = _cacheService.GetSurnameAsync(s.LastModifierId).Result
            }).OrderBy(o => o.MedicalTimes).ToList();

            return entdto;

        }


        /// <summary>
        /// 
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/CustomerOrgRegister/GetLastCustomerOrgRegisterByCustomerOrgId")]
        public async Task<CustomerOrgRegisterDto> GetLastCustomerOrgRegisterByCustomerOrgId(CustomerOrgIdInputDto input)
        {
            var entity = (await Repository.GetQueryableAsync()).Where(m => m.CustomerOrgId == input.CustomerOrgId)
                .OrderByDescending(o => o.MedicalTimes).FirstOrDefault();


            var entdto = new CustomerOrgRegisterDto()
            {
                CreationTime = entity.CreationTime,
                CreatorId = entity.CreatorId,
                Id = entity.Id,
                LastModificationTime = entity.LastModificationTime,
                LastModifierId = entity.LastModifierId,
                BeginTime = DataHelper.ConversionDateToString(entity.BeginTime),
                EndTime = DataHelper.ConversionDateToString(entity.EndTime),
                RegisterName = entity.RegisterName,
                RegisterNo = entity.RegisterNo,
                MedicalTimes = entity.MedicalTimes,
                IsComplete = entity.IsComplete,
                CustomerOrgId = entity.CustomerOrgId,
                CreatorName = _cacheService.GetSurnameAsync(entity.CreatorId).Result,
                LastModifierName = _cacheService.GetSurnameAsync(entity.LastModifierId).Result
            };

            return entdto;
        }
    }
}