hotline/src/Hotline.Api/Controllers/DataSharing/ProvinceController.cs

using DotNetCore.CAP;
using Fw.Utility.UnifyResponse;
using Hotline.DataSharing.Province.Extend;
using Hotline.DataSharing.Province.Notifications;
using Hotline.DataSharing.Province.XieTong.Receive;
using Hotline.DataSharing.Province.XieTong.Send;
using Hotline.Orders.Notifications;
using Hotline.Share.Dtos.DataSharing;
using Hotline.Share.Dtos.DataSharing.Province;
using Hotline.Share.Dtos.DataSharing.Province.XieTong.Receive;
using Hotline.Share.Dtos.Order;
using Hotline.Share.Enums.Order;
using MapsterMapper;
using MediatR;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
using XF.Domain.Filters;
using XF.Domain.Repository;

namespace Hotline.Api.Controllers.DataSharing
{
    /// <summary>
    /// 下行，省平台调用
    /// </summary>
    public class ProvinceController : BaseController
    {
        #region 注入
        private readonly IMapper _mapper;
        private readonly ICapPublisher _capPublisher;
        private readonly IMediator _mediator;
        private readonly IRepository<DsReceiveCaseInfo> _receiveCaseInfoRepository;
        private readonly IRepository<DsGetCaseBackResult> _getCaseBackResultRepository;
        private readonly IRepository<DsDelayCaseResult> _delayCaseResultRepository;
        private readonly IRepository<DsSupplyCaseInfo> _supplyCaseInfoRepository;
        private readonly IRepository<DsRevokeCaseInfo> _revokeCaseInfoRepository;
        private readonly IRepository<DsRemindCaseInfo> _remindCaseInfoRepository;
        private readonly IRepository<DsSendWarnInfo> _sendWarnInfoRepository;
        private readonly IRepository<DsSendSuperviseInfo> _sendSuperviseInfoRepository;
        private readonly IRepository<DsScreenCaseResultReceive> _screenCaseResultReceiveRepository;
        private readonly IRepository<DsSendCaseEvlResult> _sendCaseEvlResultRepository;
        private readonly IRepository<DsGetCaseReultSend> _getCaseReultSendRepository;
        private readonly IRepository<DsGetVisitInfoSend> _getVisitInfoSendRepository;
        private readonly IRepository<DsFormEnvironMent> _formEnvironMentRepository;
        private readonly IRepository<DsFormTraffic> _formTrafficRepository;
        private readonly IRepository<DsFormExpressWay> _formExpressWayRepository;
        private readonly IRepository<DsFormMedical> _formMedicalRepository;
        private readonly IRepository<DsFormNetWorktec> _formNetWorktecRepository;
        private readonly IRepository<DsFormPost> _formPostRepository;
        private readonly IRepository<DsFormReturnexChange> _formReturnexChangeRepository;
        private readonly IRepository<DsFormShamPub> _formShamPubRepository;
        private readonly IRepository<DsFormTaxationComplaint> _formTaxationComplaintRepository;
        private readonly IRepository<DsFormTaxationConsulting> _formTaxationConsultingRepository;
        private readonly IRepository<DsReceiveCaseExtends> _receiveCaseExtendsRepository;
        private readonly IRepository<DsGetCaseMaterialInfo> _getCaseMaterialInfoRepository;
        private readonly IRepository<DsSendCaseInfo> _sendCaseInfoRepository;
        private readonly IRepository<DsGetCaseBackApply> _getCaseBackApplyRepository;


        /// <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>
        /// <param name="formEnvironMentRepository"></param>
        /// <param name="formTrafficRepository"></param>
        /// <param name="formExpressWayRepository"></param>
        /// <param name="formMedicalRepository"></param>
        /// <param name="formNetWorktecRepository"></param>
        /// <param name="formPostRepository"></param>
        /// <param name="formReturnexChangeRepository"></param>
        /// <param name="formShamPubRepository"></param>
        /// <param name="formTaxationComplaintRepository"></param>
        /// <param name="formTaxationConsultingRepository"></param>
        /// <param name="receiveCaseExtendsRepository"></param>
        /// <param name="getCaseMaterialInfoRepository"></param>
        /// <param name="sendCaseInfoRepository"></param>
        /// <param name="getCaseBackApplyRepository"></param>
        public ProvinceController(IMapper mapper,
          ICapPublisher capPublisher,
           IMediator mediator,
          IRepository<DsReceiveCaseInfo> receiveCaseInfoRepository,
          IRepository<DsGetCaseBackResult> getCaseBackResultRepository,
          IRepository<DsDelayCaseResult> delayCaseResultRepository,
          IRepository<DsSupplyCaseInfo> supplyCaseInfoRepository,
          IRepository<DsRevokeCaseInfo> revokeCaseInfoRepository,
          IRepository<DsRemindCaseInfo> remindCaseInfoRepository,
          IRepository<DsSendWarnInfo> sendWarnInfoRepository,
          IRepository<DsSendSuperviseInfo> sendSuperviseInfoRepository,
          IRepository<DsScreenCaseResultReceive> screenCaseResultReceiveRepository,
          IRepository<DsSendCaseEvlResult> sendCaseEvlResultRepository,
          IRepository<DsGetCaseReultSend> getCaseReultSendRepository,
          IRepository<DsGetVisitInfoSend> getVisitInfoSendRepository,
          IRepository<DsFormEnvironMent> formEnvironMentRepository,
          IRepository<DsFormTraffic> formTrafficRepository,
          IRepository<DsFormExpressWay> formExpressWayRepository,
          IRepository<DsFormMedical> formMedicalRepository,
          IRepository<DsFormNetWorktec> formNetWorktecRepository,
          IRepository<DsFormPost> formPostRepository,
          IRepository<DsFormReturnexChange> formReturnexChangeRepository,
          IRepository<DsFormShamPub> formShamPubRepository,
          IRepository<DsFormTaxationComplaint> formTaxationComplaintRepository,
          IRepository<DsFormTaxationConsulting> formTaxationConsultingRepository,
          IRepository<DsReceiveCaseExtends> receiveCaseExtendsRepository,
          IRepository<DsGetCaseMaterialInfo> getCaseMaterialInfoRepository,
          IRepository<DsSendCaseInfo> sendCaseInfoRepository,
          IRepository<DsGetCaseBackApply> getCaseBackApplyRepository)
        {
            _mapper = mapper;
            _capPublisher = capPublisher;
            _mediator = mediator;
            _receiveCaseInfoRepository = receiveCaseInfoRepository;
            _getCaseBackResultRepository = getCaseBackResultRepository;
            _delayCaseResultRepository = delayCaseResultRepository;
            _supplyCaseInfoRepository = supplyCaseInfoRepository;
            _revokeCaseInfoRepository = revokeCaseInfoRepository;
            _remindCaseInfoRepository = remindCaseInfoRepository;
            _sendWarnInfoRepository = sendWarnInfoRepository;
            _sendSuperviseInfoRepository = sendSuperviseInfoRepository;
            _screenCaseResultReceiveRepository = screenCaseResultReceiveRepository;
            _sendCaseEvlResultRepository = sendCaseEvlResultRepository;
            _getCaseReultSendRepository = getCaseReultSendRepository;
            _getVisitInfoSendRepository = getVisitInfoSendRepository;
            _formEnvironMentRepository = formEnvironMentRepository;
            _formTrafficRepository = formTrafficRepository;
            _formExpressWayRepository = formExpressWayRepository;
            _formMedicalRepository = formMedicalRepository;
            _formNetWorktecRepository = formNetWorktecRepository;
            _formPostRepository = formPostRepository;
            _formReturnexChangeRepository = formReturnexChangeRepository;
            _formShamPubRepository = formShamPubRepository;
            _formTaxationComplaintRepository = formTaxationComplaintRepository;
            _formTaxationConsultingRepository = formTaxationConsultingRepository;
            _receiveCaseExtendsRepository = receiveCaseExtendsRepository;
            _getCaseMaterialInfoRepository = getCaseMaterialInfoRepository;
            _sendCaseInfoRepository = sendCaseInfoRepository;
            _getCaseBackApplyRepository = getCaseBackApplyRepository;
        }
        #endregion

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

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

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

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

            //处理组装数据，推送数据
            var data = _mapper.Map<AddOrderDto>(dto);
            if (dto.TrowGuid != "【政民互动直派】")
                data.IsProvince = true;

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

            //处理证件类型
            switch (dto.CertifiCateType)
            {
                case "10":
                    data.LicenceTypeCode = "10";
                    break;
                case "20":
                    data.LicenceTypeCode = "40";
                    break;
                case "30":
                    data.LicenceTypeCode = "55";
                    break;
                case "40":
                    data.LicenceTypeCode = "57";
                    break;
            }

            data.AcceptTypeCode = dto.CaseType;

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

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

            if (!string.IsNullOrEmpty(id))
            {
                //调用工单创建接口
                var result = await _mediator.Send(new ReceiveOrderNotify { AddOrderDto = data }, HttpContext.RequestAborted);
                if (result != null && !string.IsNullOrEmpty(result.Id))
                {
                    dto.Id = id;
                    dto.OrderId = result.Id;
                    await _receiveCaseInfoRepository.UpdateAsync(dto, HttpContext.RequestAborted);
                    return OpenResponse.Ok(Reponse.Success("您已成功提交数据！"));
                }
                else
                    return OpenResponse.Ok(Reponse.Failed("接口调用失败！"));
            }
            else
                return OpenResponse.Ok(Reponse.Failed("接口调用失败！"));
        }

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

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

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

            var data = await _getCaseBackApplyRepository.GetAsync(p => p.CaseSerial == dto.CaseSerial);
            if (data == null)
                return OpenResponse.Ok(Reponse.Failed("接口调用失败！"));

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

            if (!string.IsNullOrEmpty(id))
            {
                await _mediator.Send(new OrderSendBackResultNotify
                {
                    OrderSendBackResultDto = new OrderSendBackResultDto()
                    {
                        Id = data.OrderSendBackId,
                        Reason = dto.BackReason,
                        Result = dto.Result == true ? 1 : 0
                    }
                });
                return OpenResponse.Ok(Reponse.Success("您已成功提交数据！"));
            }
            else
                return OpenResponse.Ok(Reponse.Failed("接口调用失败！"));
        }

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

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

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

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

            if (!string.IsNullOrEmpty(id))
            {
                //向业务系统推送消息
                await _mediator.Send(new ProvinceOrderSuperviseNotify { ProvinceOrderSuperviseDto = _mapper.Map<ProvinceOrderSuperviseDto>(dto) });
                return OpenResponse.Ok(Reponse.Success("您已成功提交数据！"));

            }
            else
                return OpenResponse.Ok(Reponse.Failed("接口调用失败！"));
        }

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

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

            //转换数据
            var dto = _mapper.Map<DsRemindCaseInfo>(receiveRemindCaseInfo.paras);
            dto.Direction = "2";
            //添加数据
            var id = await _remindCaseInfoRepository.AddAsync(dto, HttpContext.RequestAborted);

            if (!string.IsNullOrEmpty(id))
            {
                //向业务系统推送消息
                await _mediator.Send(new ProvinceOrderUrgeNotify { ProvinceOrderUrgeDto = _mapper.Map<ProvinceOrderUrgeDto>(dto) });

                return OpenResponse.Ok(Reponse.Success("您已成功提交数据！"));
            }
            else
                return OpenResponse.Ok(Reponse.Failed("接口调用失败！"));
        }

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

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

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

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

            if (!string.IsNullOrEmpty(id))
            {
                await _mediator.Send(new ScreenProvinceResultNotify { ProvinceScreenResult = _mapper.Map<ProvinceScreenResult>(dto) });

                return OpenResponse.Ok(Reponse.Success("您已成功提交数据！"));
            }
            else
                return OpenResponse.Ok(Reponse.Failed("接口调用失败！"));
        }

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

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

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

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

            if (!string.IsNullOrEmpty(id))
            {
                //向业务系统推送消息
                await _mediator.Send(new DelayProvinceResultNotify { IsPass = dto.AuditResult == "1", Opinion = dto.AuditOpinion, No = dto.CaseSerial }, HttpContext.RequestAborted);
                return OpenResponse.Ok(Reponse.Success("您已成功提交数据！"));
            }
            else
                return OpenResponse.Ok(Reponse.Failed("接口调用失败！"));
        }

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

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

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

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


            if (!string.IsNullOrEmpty(id))
            {
                //向业务系统推送消息
                //await _capPublisher.PublishAsync(Sharing.Share.Mq.EventNames.SharingOrderSupplements, _mapper.Map<SupplementsDto>(dto), cancellationToken: HttpContext.RequestAborted);
                return OpenResponse.Ok(Reponse.Success("您已成功提交数据！"));

            }
            else
                return OpenResponse.Ok(Reponse.Failed("接口调用失败！"));
        }

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

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

            //转换数据
            var dto = _mapper.Map<DsRevokeCaseInfo>(receiveRevokeCaseInfo.paras);
            dto.Direction = "2";
            //添加数据
            var id = await _revokeCaseInfoRepository.AddAsync(dto, HttpContext.RequestAborted);

            if (!string.IsNullOrEmpty(id))
            {
                //向业务系统推送消息
                //  await _capPublisher.PublishAsync(Sharing.Share.Mq.EventNames.SharingOrderRevoke, _mapper.Map<RevokeDto>(dto), cancellationToken: HttpContext.RequestAborted);
                return OpenResponse.Ok(Reponse.Success("您已成功提交数据！"));
            }
            else
                return OpenResponse.Ok(Reponse.Failed("接口调用失败！"));
        }

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

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

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

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

            if (!string.IsNullOrEmpty(id))
            {
                //向业务系统推送消息
                //await _capPublisher.PublishAsync(Sharing.Share.Mq.EventNames.SharingOrderWarning, _mapper.Map<WarningDto>(dto), cancellationToken: HttpContext.RequestAborted);
                return OpenResponse.Ok(Reponse.Success("您已成功提交数据！"));
            }
            else
                return OpenResponse.Ok(Reponse.Failed("接口调用失败！"));
        }

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

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

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

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

            if (!string.IsNullOrEmpty(id))
            {
                //向业务系统推送消息
                //await _capPublisher.PublishAsync(Sharing.Share.Mq.EventNames.SharingOrderEvlResult, _mapper.Map<EvlResultDto>(dto), cancellationToken: HttpContext.RequestAborted);
                return OpenResponse.Ok(Reponse.Success("您已成功提交数据！"));
            }
            else
                return OpenResponse.Ok(Reponse.Failed("接口调用失败！"));
        }

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

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

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

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

            if (!string.IsNullOrEmpty(id))
            {
                //查询此工单
                var tempData = await _sendCaseInfoRepository.GetAsync(p => p.CaseSerial == dto.CaseSerial, HttpContext.RequestAborted);
                if (tempData != null)
                {
                    //将工单的办理状态改为办理完成，终止拉取办理信息
                    tempData.IsEnd = true;
                    await _sendCaseInfoRepository.UpdateAsync(tempData, HttpContext.RequestAborted);
                }
                //向业务系统推送消息
                //await _capPublisher.PublishAsync(Sharing.Share.Mq.EventNames.SharingOrderReultSend, _mapper.Map<ReultSendDto>(dto), cancellationToken: HttpContext.RequestAborted);
                return OpenResponse.Ok(Reponse.Success("您已成功提交数据！"));
            }
            else
                return OpenResponse.Ok(Reponse.Failed("接口调用失败！"));
        }

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

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

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

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

            if (!string.IsNullOrEmpty(id))
            {
                //向业务系统推送消息
                // await _capPublisher.PublishAsync(Sharing.Share.Mq.EventNames.SharingOrderVisitInfo, _mapper.Map<VisitInfoDto>(dto), cancellationToken: HttpContext.RequestAborted);
                return OpenResponse.Ok(Reponse.Success("您已成功提交数据！"));
            }
            else
                return OpenResponse.Ok(Reponse.Failed("接口调用失败！"));
        }

        /// <summary>
        /// 服务工单拓展信息交办---已完成-----1
        /// </summary>
        /// <param name="receiveCaseExtendsRequest">服务工单拓展信息交办</param>
        /// <returns></returns>
        [HttpPost]
        [Route("rest/receive_case_extends")]
        [AllowAnonymous]
        public async Task<OpenResponse> ReceiveCaseExtends([FromBody] ReceiveCaseExtendsRequest receiveCaseExtendsRequest)
        {
            // 验证
            if (receiveCaseExtendsRequest is null || receiveCaseExtendsRequest.paras is null)
                return OpenResponse.Ok(Reponse.Failed("数据解析失败"));

            string strResult = receiveCaseExtendsRequest.paras.Validate();
            if (!string.IsNullOrEmpty(strResult))
                return OpenResponse.Ok(Reponse.Failed(strResult));

            var data = receiveCaseExtendsRequest.paras;

            //扩展主表信息
            DsReceiveCaseExtends receiveCaseExtends = new()
            {
                CaseSerial = data.CaseSerial,
                FormType = data.FormType,
                SyncState = "1",
                Direction = "2"
            };
            var id = await _receiveCaseExtendsRepository.AddAsync(receiveCaseExtends, HttpContext.RequestAborted);
            if (!string.IsNullOrEmpty(id))
                return OpenResponse.Ok(Reponse.Failed("数据提交失败"));

            OrderExtensionDto orderExtension = new()
            {
                ProvinceNo = data.CaseSerial,
                OrderTypeCode = data.FormType.ToLower()
            };
            //扩展信息写入
            switch (data.FormType.ToLower())
            {
                case "yl"://医疗表单
                    //转换数据
                    var dtoyl = _mapper.Map<DsFormMedical>(data.FormMedical);
                    dtoyl.RCEId = id;
                    //添加数据
                    await _formMedicalRepository.AddAsync(dtoyl, HttpContext.RequestAborted);
                    orderExtension = _mapper.Map<OrderExtensionDto>(dtoyl);
                    orderExtension.OrderType = "医疗服务中心受理单";
                    break;
                case "zwfw"://四川政务服务网技术工单
                    //转换数据
                    var dtozwfw = _mapper.Map<DsFormNetWorktec>(data.FormNetWorktec);
                    dtozwfw.RCEId = id;
                    //添加数据
                    await _formNetWorktecRepository.AddAsync(dtozwfw, HttpContext.RequestAborted);
                    orderExtension = _mapper.Map<OrderExtensionDto>(dtozwfw);
                    orderExtension.OrderType = "四川政务服务网技术中心受理单";
                    break;
                case "th"://电视购物及商铺购买退换货工单
                    //转换数据
                    var dtoth = _mapper.Map<DsFormReturnexChange>(data.FormReturnexChange);
                    dtoth.RCEId = id;
                    //添加数据
                    await _formReturnexChangeRepository.AddAsync(dtoth, HttpContext.RequestAborted);
                    orderExtension = _mapper.Map<OrderExtensionDto>(dtoth);
                    orderExtension.OrderType = "电视购物及商铺购买退换货中心受理单";
                    break;
                case "gsgl"://高速公路工单
                    //转换数据
                    var dtogsgl = _mapper.Map<DsFormExpressWay>(data.FormExpressWay);
                    dtogsgl.RCEId = id;
                    //添加数据
                    await _formExpressWayRepository.AddAsync(dtogsgl, HttpContext.RequestAborted);
                    orderExtension = _mapper.Map<OrderExtensionDto>(dtogsgl);
                    orderExtension.OrderType = "高速公路投诉中心受理单";
                    break;
                case "xjgg"://电视台虚假广告工单
                    //转换数据
                    var dtoxjgg = _mapper.Map<DsFormShamPub>(data.FormShamPub);
                    dtoxjgg.RCEId = id;
                    //添加数据
                    await _formShamPubRepository.AddAsync(dtoxjgg, HttpContext.RequestAborted);
                    orderExtension = _mapper.Map<OrderExtensionDto>(dtoxjgg);
                    orderExtension.OrderType = "电视台虚假广告中心受理单";
                    break;
                case "swfwsq"://12366热线诉求交办
                    //转换数据
                    var dtoswfwsq = _mapper.Map<DsFormTaxationComplaint>(data.FormTaxationComplaint);
                    dtoswfwsq.RCEId = id;
                    //添加数据
                    await _formTaxationComplaintRepository.AddAsync(dtoswfwsq, HttpContext.RequestAborted);
                    orderExtension = _mapper.Map<OrderExtensionDto>(dtoswfwsq);
                    orderExtension.OrderType = "四川省12366热线诉求交办单";
                    break;
                case "swfwzx"://12366热线咨询交办
                    //转换数据
                    var dtoswfwzx = _mapper.Map<DsFormTaxationConsulting>(data.FormTaxationConsulting);
                    dtoswfwzx.RCEId = id;
                    //添加数据
                    await _formTaxationConsultingRepository.AddAsync(dtoswfwzx, HttpContext.RequestAborted);
                    orderExtension = _mapper.Map<OrderExtensionDto>(dtoswfwzx);
                    orderExtension.OrderType = "四川省12366热线咨询交办单";
                    break;
                case "jtfwjd"://12328服务监督
                    //转换数据
                    var dtojtfwjd = _mapper.Map<DsFormTraffic>(data.FormTraffic);
                    dtojtfwjd.RCEId = id;
                    //添加数据
                    await _formTrafficRepository.AddAsync(dtojtfwjd, HttpContext.RequestAborted);
                    orderExtension = _mapper.Map<OrderExtensionDto>(dtojtfwjd);
                    orderExtension.OrderType = "12328服务监督中心受理单";
                    break;
                case "yzxf"://邮政业消费者申诉
                    //转换数据
                    var dtoyzxf = _mapper.Map<DsFormPost>(data.FormPost);
                    dtoyzxf.RCEId = id;
                    //添加数据
                    await _formPostRepository.AddAsync(dtoyzxf, HttpContext.RequestAborted);
                    orderExtension = _mapper.Map<OrderExtensionDto>(dtoyzxf);
                    orderExtension.OrderType = "邮政业消费者申诉受理单";
                    break;
                case "hbjb"://环保举报业务
                    //转换数据
                    var dtohbjb = _mapper.Map<DsFormEnvironMent>(data.FormEnvironMent);
                    dtohbjb.RCEId = id;
                    //添加数据
                    await _formEnvironMentRepository.AddAsync(dtohbjb, HttpContext.RequestAborted);
                    orderExtension = _mapper.Map<OrderExtensionDto>(dtohbjb);
                    orderExtension.OrderType = "环保举报业务受理单";
                    break;
                case "scjgj"://12315个性化表单
                    break;
                default:
                    break;
            }

            if (!string.IsNullOrEmpty(id))
            {
                //向业务系统推送消息
                await _mediator.Send(new ReceiveOrderExtensionNotify { OrderExtensionDto = orderExtension });

                return OpenResponse.Ok(Reponse.Success("您已成功提交数据！"));

            }
            else
                return OpenResponse.Ok(Reponse.Failed("接口调用失败！"));
        }

        /// <summary>
        /// 服务工单材料接口
        /// </summary>
        /// <param name="params">工单材料信息</param>
        /// <param name="files">材料文件</param>
        /// <returns></returns>
        [HttpPost]
        [Route("get_case_material_info")]
        [AllowAnonymous]
        public async Task<OpenResponse> GetCaseMaterialInfo(string @params, List<IFormFile> files)
        {
            // 上传文件为必须
            if (files is null || files.Count <= 0)
            {
                return OpenResponse.Ok(Reponse.Failed("上传文件为必须"));
            }

            // 解析附件信息
            var vmCaseMaterialInfo = Newtonsoft.Json.JsonConvert.DeserializeObject<GetCaseMaterialInfoRequest>(@params);
            if (vmCaseMaterialInfo is null || vmCaseMaterialInfo.paras is null)
            {
                return OpenResponse.Ok(Reponse.Failed("数据解析失败"));
            }
            GetCaseMaterialInfoModel tmpCaseMaterialInfo = vmCaseMaterialInfo.paras;

            // 验证
            string strResult = tmpCaseMaterialInfo.Validate();
            if (false == string.IsNullOrEmpty(strResult))
            {
                return OpenResponse.Ok(Reponse.Failed(strResult));
            }

            // 文件列表
            foreach (var file in files)
            {
                // 文件内容字节数据
                using var memoryStream = new MemoryStream();
                await file.CopyToAsync(memoryStream);
                memoryStream.Seek(0, SeekOrigin.Begin);
                byte[] fileContentBytes = memoryStream.ToArray();

                //这里需要上文件服务器上传
                var Additions = await SendFileData(fileContentBytes);

                // 新增文件到列表
                var materialInfo = new DsGetCaseMaterialInfo()
                {
                    CaseSerial = tmpCaseMaterialInfo.CaseSerial,
                    MaterialType = tmpCaseMaterialInfo.MaterialType,
                    CliengGuid = tmpCaseMaterialInfo.CliengGuid,
                    AreaCode = tmpCaseMaterialInfo.AreaCode,
                    FileName = file.FileName,
                    FileSize = file.Length,
                    Additions = Additions,
                    Direction = "2",
                    SyncState = "1"
                };
                await _getCaseMaterialInfoRepository.AddAsync(materialInfo, HttpContext.RequestAborted);
                //向业务系统推送消息
                //  await _capPublisher.PublishAsync(Sharing.Share.Mq.EventNames.SharingFileData, _mapper.Map<FileDto>(materialInfo), cancellationToken: HttpContext.RequestAborted);
            }

            return OpenResponse.Ok(Reponse.Success("您已成功提交数据！"));
        }

        //还需要将附件上传到业务服务器

        /// <summary>
        /// 将文件流上传到附件服务器
        /// </summary>
        /// <param name="fileContentBytes"></param>
        /// <returns></returns>
        private async Task<string> SendFileData(byte[] fileContentBytes)
        {
            return "";
        }
    }
}