sharing/src/Sharing.Province/Controllers/ReceiveController.cs

using DotNetCore.CAP;
using Hotline.Share.Enums.Order;
using MapsterMapper;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using Sharing.Province.Dtos;
using Sharing.Province.Dtos.XieTong.Receive;
using Sharing.Province.XieTong.Receive;
using Sharing.WebCore;

namespace Sharing.Province.Controllers
{

    /// <summary>
    /// 
    /// </summary>
    public class ReceiveController : BaseController
    {
        #region 注入
        private readonly IMapper _mapper;
        private readonly ICapPublisher _capPublisher;
        private readonly IReceiveCaseInfoRepository _receiveCaseInfoRepository;
        private readonly IGetCaseBackResultRepository _getCaseBackResultRepository;
        private readonly IDelayCaseResultRepository _delayCaseResultRepository;
        private readonly ISupplyCaseInfoRepository _supplyCaseInfoRepository;
        private readonly IRevokeCaseInfoRepository _revokeCaseInfoRepository;
        private readonly IRemindCaseInfoRepository _remindCaseInfoRepository;
        private readonly ISendWarnInfoRepository _sendWarnInfoRepository;
        private readonly ISendSuperviseInfoRepository _sendSuperviseInfoRepository;
        private readonly IScreenCaseResultReceiveRepository _screenCaseResultReceiveRepository;
        private readonly ISendCaseEvlResultRepository _sendCaseEvlResultRepository;
        private readonly IGetCaseReultSendRepository _getCaseReultSendRepository;
        private readonly IGetVisitInfoSendRepository _getVisitInfoSendRepository;

        /// <summary>
        /// 
        /// </summary>
        /// <param name="mapper"></param>
        /// <param name="capPublisher"></param>
        /// <param name="receiveCaseInfoRepository"></param>
        /// <param name="getCaseBackResultRepository"></param>
        /// <param name="delayCaseResultRepository"></param>
        /// <param name="supplyCaseInfoRepository"></param>
        /// <param name="revokeCaseInfoRepository"></param>
        /// <param name="remindCaseInfoRepository"></param>
        /// <param name="sendWarnInfoRepository"></param>
        /// <param name="sendSuperviseInfoRepository"></param>
        /// <param name="screenCaseResultReceiveRepository"></param>
        /// <param name="sendCaseEvlResultRepository"></param>
        /// <param name="getCaseReultSendRepository"></param>
        /// <param name="getVisitInfoSendRepository"></param>
        public ReceiveController(IMapper mapper, ICapPublisher capPublisher, IReceiveCaseInfoRepository receiveCaseInfoRepository,
            IGetCaseBackResultRepository getCaseBackResultRepository, IDelayCaseResultRepository delayCaseResultRepository
            , ISupplyCaseInfoRepository supplyCaseInfoRepository, IRevokeCaseInfoRepository revokeCaseInfoRepository
            , IRemindCaseInfoRepository remindCaseInfoRepository, ISendWarnInfoRepository sendWarnInfoRepository
            , ISendSuperviseInfoRepository sendSuperviseInfoRepository, IScreenCaseResultReceiveRepository screenCaseResultReceiveRepository
            , ISendCaseEvlResultRepository sendCaseEvlResultRepository, IGetCaseReultSendRepository getCaseReultSendRepository
            , IGetVisitInfoSendRepository getVisitInfoSendRepository)
        {
            _mapper = mapper;
            _capPublisher = capPublisher;
            _receiveCaseInfoRepository = receiveCaseInfoRepository;
            _getCaseBackResultRepository = getCaseBackResultRepository;
            _delayCaseResultRepository = delayCaseResultRepository;
            _supplyCaseInfoRepository = supplyCaseInfoRepository;
            _revokeCaseInfoRepository = revokeCaseInfoRepository;
            _remindCaseInfoRepository = remindCaseInfoRepository;
            _sendWarnInfoRepository = sendWarnInfoRepository;
            _sendSuperviseInfoRepository = sendSuperviseInfoRepository;
            _screenCaseResultReceiveRepository = screenCaseResultReceiveRepository;
            _sendCaseEvlResultRepository = sendCaseEvlResultRepository;
            _getCaseReultSendRepository = getCaseReultSendRepository;
            _getVisitInfoSendRepository = getVisitInfoSendRepository;
        }
        #endregion

        /// <summary>
        /// 服务工单交办接口
        /// </summary>
        /// <param name="receiveCaseInfo"></param>
        /// <returns></returns>
        [HttpPost("receive_case_info")]
        [AllowAnonymous]
        public async Task<Reponse> ReceiveCaseInfo([FromBody] ReceiveCaseInfoRequest receiveCaseInfo)
        {
            // 验证
            if (receiveCaseInfo is null || receiveCaseInfo.paras is null)
            {
                Reponse.Failed("数据解析失败");
            }

            //验证接收的数据是否正确
            string strResult = receiveCaseInfo.paras.Validate();
            if (!string.IsNullOrEmpty(strResult))
                Reponse.Failed(strResult);

            //转换数据
            var dto = _mapper.Map<ReceiveCaseInfo>(receiveCaseInfo.paras);

            //添加数据
            var id = await _receiveCaseInfoRepository.AddAsync(dto, HttpContext.RequestAborted);

            //处理组装数据，推送数据

            #region 处理接收的数据
            ReceiveCaseInfoAddOrderDto addOrderDto = new()
            {
                ProvinceNo = dto.CaseSerial,
                Title = dto.CaseTitle,
                CaseRegister = dto.CaseRegister,
                CaseRegisterNo = dto.CaseRegisterNo,
                CaseDate = dto.CaseDate,
                FromPhone = dto.PhoneNumber,
                Contact = dto.PhoneNumber,
                FromName = dto.AppLicantName,
                Content = dto.CaseContent,
                CaseProcessType = dto.CaseProcessType,
                TSigntTmeBf = dto.TSigntTmeBf,
                TfdBackTimeBf = dto.TfdBackTimeBf,
                TBackTimeBf = dto.TBackTimeBf,
                AreaCode = dto.AreaCode,
                Street = dto.CaseAddress,
                IncidentTime = dto.EventDate,
                HotspotCode = dto.CaseAccord,
                LicenceNo = dto.AppLicantId,
                AgeRangeCode = dto.AppLicantAge,
                TaskType = dto.TaskType,
                IsPublic = dto.CaseIsPublic == "1",
                IsSecrect = dto.CaseIsSecrect == "1",
                IsVisit = dto.CaseIsVisit == "1",
                CaseEmotion = dto.CaseEmotion,
                TrowGuid = dto.TrowGuid,
                CliengGuid = dto.CliengGuid,
                AdviseType = dto.AdviseType,
                AdviseDept = dto.AdviseDept,
                ComplainType = dto.ComplainType,
                ComplainDept = dto.ComplainDept
            };

            //处理诉求渠道
            switch (dto.CaseSource.ToUpper())
            {
                case "RGDH":
                    addOrderDto.Channel = EChannel.Phone;
                    break;
                case "WX":
                    addOrderDto.Channel = EChannel.WxOfficial;
                    break;
                case "WZ":
                    addOrderDto.Channel = EChannel.Web;
                    break;
                case "AP":
                    addOrderDto.Channel = EChannel.App;
                    break;
                case "XCX":
                    addOrderDto.Channel = EChannel.WxMiniProgram;
                    break;
                default:
                    break;
            }

            //处理性别
            switch (dto.AppLicantSex)
            {
                case "0":
                    addOrderDto.FromGender = EGender.Female;
                    break;
                case "1":
                    addOrderDto.FromGender = EGender.Male;
                    break;
                case "2":
                    addOrderDto.FromGender = EGender.Unknown;
                    break;
                default:
                    break;
            }

            //处理年龄范围名称
            switch (dto.AppLicantAge)
            {
                case "10":
                    addOrderDto.AgeRange = "20以下";
                    break;
                case "20":
                    addOrderDto.AgeRange = "20-39";
                    break;
                case "30":
                    addOrderDto.AgeRange = "40-59";
                    break;
                case "40":
                    addOrderDto.AgeRange = "60岁以上";
                    break;
                case "70":
                    addOrderDto.AgeRange = "无法获取";
                    break;
                default:
                    break;
            }

            //处理证件类型
            switch (dto.CertifiCateType)
            {
                case "10":
                    addOrderDto.LicenceTypeCode = "10";
                    addOrderDto.LicenceType = "中华人民共和国居民身份证";
                    break;
                case "20":
                    addOrderDto.LicenceTypeCode = "40";
                    addOrderDto.LicenceType = "外国（地区）护照";
                    break;
                case "30":
                    addOrderDto.LicenceTypeCode = "55";
                    addOrderDto.LicenceType = "港澳居民来往内地通行证";
                    break;
                case "40":
                    addOrderDto.LicenceTypeCode = "57";
                    addOrderDto.LicenceType = "台湾居民来往大陆通行证";
                    break;
                default:
                    addOrderDto.LicenceTypeCode = "90";
                    addOrderDto.LicenceType = "其他有效身份证件";
                    break;
            }

            //处理受理类型
            switch (dto.CaseType)
            {
                case "10":
                    addOrderDto.AcceptType = EAcceptType.Consult;
                    break;
                case "15":
                    addOrderDto.AcceptType = EAcceptType.Suggest;
                    break;
                case "20":
                    addOrderDto.AcceptType = EAcceptType.SeekHelp;
                    break;
                case "25":
                    addOrderDto.AcceptType = EAcceptType.Praise;
                    break;
                case "30":
                    addOrderDto.AcceptType = EAcceptType.Report;
                    break;
                case "35":
                    addOrderDto.AcceptType = EAcceptType.Report;
                    break;
                case "40":
                    addOrderDto.AcceptType = EAcceptType.Other;
                    break;
                default:
                    break;
            }

            //处理紧急程度
            switch (dto.CaseIsUrgent)
            {
                case "10":
                    addOrderDto.EmergencyLevel = EEmergencyLevel.QuiteEmergency;
                    break;
                case "20":
                    addOrderDto.EmergencyLevel = EEmergencyLevel.Emergency;
                    break;
                case "30":
                    addOrderDto.EmergencyLevel = EEmergencyLevel.Normal;
                    break;
                default:
                    break;
            }

            //经纬度处理
            var lngLat = dto.CaseLngLat.Split(',');
            if (lngLat != null && lngLat.Length == 2)
            {
                addOrderDto.Longitude = Convert.ToDouble(lngLat[0]);
                addOrderDto.Latitude = Convert.ToDouble(lngLat[1]);
            }

            #endregion

            //向业务系统推送消息
            // await _capPublisher.PublishAsync(EventNames.HotlineOrderCreated, addOrderDto,cancellationToken: HttpContext.RequestAborted);

            if (!string.IsNullOrEmpty(id))
                return Reponse.Success("您已成功提交数据！");
            else
                return Reponse.Failed("接口调用失败！");
        }

        /// <summary>
        /// 服务工单退回反馈接口
        /// </summary>
        /// <param name="receiveBackResult">退回反馈</param>
        /// <returns></returns>
        [HttpPost("get_case_back_result")]
        [AllowAnonymous]
        public async Task<Reponse> GetCaseBackResult([FromBody] GetCaseBackResultRequest receiveBackResult)
        {
            // 验证
            if (receiveBackResult is null || receiveBackResult.paras is null)
                Reponse.Failed("数据解析失败");

            //验证接收的数据是否正确
            string strResult = receiveBackResult.paras.Validate();
            if (!string.IsNullOrEmpty(strResult))
                Reponse.Failed(strResult);

            //转换数据
            var dto = _mapper.Map<GetCaseBackResult>(receiveBackResult.paras);

            //添加数据
            var id = await _getCaseBackResultRepository.AddAsync(dto, HttpContext.RequestAborted);

            //向业务系统推送消息
            // await _capPublisher.PublishAsync(EventNames.HotlineOrderCreated, dto,cancellationToken: HttpContext.RequestAborted);

            if (!string.IsNullOrEmpty(id))
                return Reponse.Success("您已成功提交数据！");
            else
                return Reponse.Failed("接口调用失败！");
        }

        /// <summary>
        /// 服务工单延时审核结果接口
        /// </summary>
        /// <param name="receiveDelayCaseResult">延时审核结果对象</param>
        /// <returns></returns>
        [HttpPost("delay_case_result_receive")]
        [AllowAnonymous]
        public async Task<Reponse> DelayCaseResultReceive([FromBody] DelayCaseResultRequest receiveDelayCaseResult)
        {
            // 验证
            if (receiveDelayCaseResult is null || receiveDelayCaseResult.paras is null)
                Reponse.Failed("数据解析失败");

            string strResult = receiveDelayCaseResult.paras.Validate();
            if (!string.IsNullOrEmpty(strResult))
                Reponse.Failed(strResult);

            //转换数据
            var dto = _mapper.Map<DelayCaseResult>(receiveDelayCaseResult.paras);

            //添加数据
            var id = await _delayCaseResultRepository.AddAsync(dto, HttpContext.RequestAborted);

            //向业务系统推送消息
            // await _capPublisher.PublishAsync(EventNames.HotlineOrderCreated, dto,cancellationToken: HttpContext.RequestAborted);

            if (!string.IsNullOrEmpty(id))
                return Reponse.Success("您已成功提交数据！");
            else
                return Reponse.Failed("接口调用失败！");
        }

        /// <summary>
        /// 服务工单交办补充诉求接口
        /// </summary>
        /// <param name="receiveSupplyCaseInfo">交办补充诉求对象</param>
        /// <returns></returns>
        [HttpPost("supply_case_info_receive")]
        [AllowAnonymous]
        public async Task<Reponse> SupplyCaseInfoReceive([FromBody] SupplyCaseInfoRequest receiveSupplyCaseInfo)
        {
            // 验证
            if (receiveSupplyCaseInfo is null || receiveSupplyCaseInfo.paras is null)
                Reponse.Failed("数据解析失败");

            string strResult = receiveSupplyCaseInfo.paras.Validate();
            if (!string.IsNullOrEmpty(strResult))
                Reponse.Failed(strResult);

            //转换数据
            var dto = _mapper.Map<SupplyCaseInfo>(receiveSupplyCaseInfo.paras);

            //添加数据
            var id = await _supplyCaseInfoRepository.AddAsync(dto, HttpContext.RequestAborted);

            //向业务系统推送消息
            // await _capPublisher.PublishAsync(EventNames.HotlineOrderCreated, dto,cancellationToken: HttpContext.RequestAborted);

            if (!string.IsNullOrEmpty(id))
                return Reponse.Success("您已成功提交数据！");
            else
                return Reponse.Failed("接口调用失败！");
        }

        /// <summary>
        /// 服务工单撤单接口
        /// </summary>
        /// <param name="receiveRevokeCaseInfo">撤单对象</param>
        /// <returns></returns>
        [HttpPost("revoke_case_info")]
        [AllowAnonymous]
        public async Task<Reponse> RevokeCaseInfo([FromBody] RevokeCaseInfoRequest receiveRevokeCaseInfo)
        {
            // 验证
            if (receiveRevokeCaseInfo is null || receiveRevokeCaseInfo.paras is null)
                Reponse.Failed("数据解析失败");

            string strResult = receiveRevokeCaseInfo.paras.Validate();
            if (!string.IsNullOrEmpty(strResult))
                Reponse.Failed(strResult);

            //转换数据
            var dto = _mapper.Map<RevokeCaseInfo>(receiveRevokeCaseInfo.paras);

            //添加数据
            var id = await _revokeCaseInfoRepository.AddAsync(dto, HttpContext.RequestAborted);

            //向业务系统推送消息
            // await _capPublisher.PublishAsync(EventNames.HotlineOrderCreated, dto,cancellationToken: HttpContext.RequestAborted);

            if (!string.IsNullOrEmpty(id))
                return Reponse.Success("您已成功提交数据！");
            else
                return Reponse.Failed("接口调用失败！");
        }

        /// <summary>
        /// 服务工单催单接口
        /// </summary>
        /// <param name="receiveRemindCaseInfo">催单对象</param>
        /// <returns></returns>
        [HttpPost("remind_case_info")]
        [AllowAnonymous]
        public async Task<Reponse> RemindCaseInfo([FromBody] RemindCaseInfoRequest receiveRemindCaseInfo)
        {
            // 验证
            if (receiveRemindCaseInfo is null || receiveRemindCaseInfo.paras is null)
                Reponse.Failed("数据解析失败");

            string strResult = receiveRemindCaseInfo.paras.Validate();
            if (!string.IsNullOrEmpty(strResult))
                Reponse.Failed(strResult);

            //转换数据
            var dto = _mapper.Map<RemindCaseInfo>(receiveRemindCaseInfo.paras);

            //添加数据
            var id = await _remindCaseInfoRepository.AddAsync(dto, HttpContext.RequestAborted);

            //向业务系统推送消息
            // await _capPublisher.PublishAsync(EventNames.HotlineOrderCreated, dto,cancellationToken: HttpContext.RequestAborted);

            if (!string.IsNullOrEmpty(id))
                return Reponse.Success("您已成功提交数据！");
            else
                return Reponse.Failed("接口调用失败！");
        }

        /// <summary>
        /// 服务工单预警接口
        /// </summary>
        /// <param name="receiveSendWarnInfo">预警对象</param>
        /// <returns></returns>
        [HttpPost("send_warn_info")]
        [AllowAnonymous]
        public async Task<Reponse> SendWarnInfo([FromBody] SendWarnInfoRequest receiveSendWarnInfo)
        {
            // 验证
            if (receiveSendWarnInfo is null || receiveSendWarnInfo.paras is null)
                Reponse.Failed("数据解析失败");

            string strResult = receiveSendWarnInfo.paras.Validate();
            if (!string.IsNullOrEmpty(strResult))
                Reponse.Failed(strResult);

            //转换数据
            var dto = _mapper.Map<SendWarnInfo>(receiveSendWarnInfo.paras);

            //添加数据
            var id = await _sendWarnInfoRepository.AddAsync(dto, HttpContext.RequestAborted);

            //向业务系统推送消息
            // await _capPublisher.PublishAsync(EventNames.HotlineOrderCreated, dto,cancellationToken: HttpContext.RequestAborted);

            if (!string.IsNullOrEmpty(id))
                return Reponse.Success("您已成功提交数据！");
            else
                return Reponse.Failed("接口调用失败！");
        }

        /// <summary>
        /// 督办工单派发接口
        /// </summary>
        /// <param name="receiveSendSuperviseInfo">督办工单对象</param>
        /// <returns></returns>
        [HttpPost("send_supervise_info")]
        [AllowAnonymous]
        public async Task<Reponse> SendSuperviseInfo([FromBody] SendSuperviseInfoRequest receiveSendSuperviseInfo)
        {
            // 验证
            if (receiveSendSuperviseInfo is null || receiveSendSuperviseInfo.paras is null)
                Reponse.Failed("数据解析失败");

            string strResult = receiveSendSuperviseInfo.paras.Validate();
            if (!string.IsNullOrEmpty(strResult))
                Reponse.Failed(strResult);

            //转换数据
            var dto = _mapper.Map<SendSuperviseInfo>(receiveSendSuperviseInfo.paras);

            //添加数据
            var id = await _sendSuperviseInfoRepository.AddAsync(dto, HttpContext.RequestAborted);

            //向业务系统推送消息
            // await _capPublisher.PublishAsync(EventNames.HotlineOrderCreated, dto,cancellationToken: HttpContext.RequestAborted);

            if (!string.IsNullOrEmpty(id))
                return Reponse.Success("您已成功提交数据！");
            else
                return Reponse.Failed("接口调用失败！");
        }

        /// <summary>
        /// 服务工单甄别结果接口
        /// </summary>
        /// <param name="receiveScreenCaseResultReceive">服务工单甄别结果对象</param>
        /// <returns></returns>
        [HttpPost("screen_case_result_receive")]
        [AllowAnonymous]
        public async Task<Reponse> ScreenCaseResultReceive([FromBody] ScreenCaseResultReceiveRequest receiveScreenCaseResultReceive)
        {
            // 验证
            if (receiveScreenCaseResultReceive is null || receiveScreenCaseResultReceive.paras is null)
                return Reponse.Failed("数据解析失败");

            string strResult = receiveScreenCaseResultReceive.paras.Validate();
            if (!string.IsNullOrEmpty(strResult))
                return Reponse.Failed(strResult);

            //转换数据
            var dto = _mapper.Map<ScreenCaseResultReceive>(receiveScreenCaseResultReceive.paras);

            //添加数据
            var id = await _screenCaseResultReceiveRepository.AddAsync(dto, HttpContext.RequestAborted);

            //向业务系统推送消息
            // await _capPublisher.PublishAsync(EventNames.HotlineOrderCreated, dto,cancellationToken: HttpContext.RequestAborted);
            if (!string.IsNullOrEmpty(id))
                return Reponse.Success("您已成功提交数据！");
            else
                return Reponse.Failed("接口调用失败！");

        }

        /// <summary>
        /// 交办工单满意度接收接口
        /// </summary>
        /// <param name="receiveSendCaseEvlResult">交办工单满意度对象</param>
        /// <returns></returns>
        [HttpPost("send_case_evl_result")]
        [AllowAnonymous]
        public async Task<Reponse> SendCaseEvlResult([FromBody] SendCaseEvlResultRequest receiveSendCaseEvlResult)
        {
            // 验证
            if (receiveSendCaseEvlResult is null || receiveSendCaseEvlResult.paras is null)
                return Reponse.Failed("数据解析失败");

            string strResult = receiveSendCaseEvlResult.paras.Validate();
            if (!string.IsNullOrEmpty(strResult))
                return Reponse.Failed(strResult);

            //转换数据
            var dto = _mapper.Map<SendCaseEvlResult>(receiveSendCaseEvlResult.paras);

            //添加数据
            var id = await _sendCaseEvlResultRepository.AddAsync(dto, HttpContext.RequestAborted);

            //向业务系统推送消息
            // await _capPublisher.PublishAsync(EventNames.HotlineOrderCreated, dto,cancellationToken: HttpContext.RequestAborted);
            if (!string.IsNullOrEmpty(id))
                return Reponse.Success("您已成功提交数据！");
            else
                return Reponse.Failed("接口调用失败！");

        }

        /// <summary>
        /// 上报工单处理结果/退回接口
        /// </summary>
        /// <param name="receiveGetCaseReultSend">上报工单处理结果/退回对象</param>
        /// <returns></returns>
        [HttpPost]
        [Route("get_case_result_send")]
        public async Task<Reponse> GetCaseReultSend([FromBody] GetCaseReultSendRequest receiveGetCaseReultSend)
        {
            // 验证
            if (receiveGetCaseReultSend is null || receiveGetCaseReultSend.paras is null)
                return Reponse.Failed("数据解析失败");

            string strResult = receiveGetCaseReultSend.paras.Validate();
            if (!string.IsNullOrEmpty(strResult))
                return Reponse.Failed(strResult);

            //转换数据
            var dto = _mapper.Map<GetCaseReultSend>(receiveGetCaseReultSend.paras);

            //添加数据
            var id = await _getCaseReultSendRepository.AddAsync(dto, HttpContext.RequestAborted);

            //向业务系统推送消息
            // await _capPublisher.PublishAsync(EventNames.HotlineOrderCreated, dto,cancellationToken: HttpContext.RequestAborted);
            if (!string.IsNullOrEmpty(id))
                return Reponse.Success("您已成功提交数据！");
            else
                return Reponse.Failed("接口调用失败！");
        }

        /// <summary>
        /// 上报工单评价接口
        /// </summary>
        /// <param name="receiveGetVisitInfoSend">上报工单评价对象</param>
        /// <returns></returns>
        [HttpPost]
        [Route("get_visit_info_send")]
        public async Task<Reponse> GetVisitInfoSend([FromBody] GetCaseReultSendRequest receiveGetVisitInfoSend)
        {
            // 验证
            if (receiveGetVisitInfoSend is null || receiveGetVisitInfoSend.paras is null)
                return Reponse.Failed("数据解析失败");

            string strResult = receiveGetVisitInfoSend.paras.Validate();
            if (!string.IsNullOrEmpty(strResult))
                return Reponse.Failed(strResult);

            //转换数据
            var dto = _mapper.Map<GetVisitInfoSend>(receiveGetVisitInfoSend.paras);

            //添加数据
            var id = await _getVisitInfoSendRepository.AddAsync(dto, HttpContext.RequestAborted);

            //向业务系统推送消息
            // await _capPublisher.PublishAsync(EventNames.HotlineOrderCreated, dto,cancellationToken: HttpContext.RequestAborted);
            if (!string.IsNullOrEmpty(id))
                return Reponse.Success("您已成功提交数据！");
            else
                return Reponse.Failed("接口调用失败！");
        }
    }
}