WebPeis0523/src/Shentun.WebPeis.Application/Persons/PersonAppService.cs

using Shentun.WebPeis.Models;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using Volo.Abp.Application.Services;
using Volo.Abp.Domain.Entities;
using Volo.Abp.Domain.Repositories;
using Volo.Abp.Users;
using Shentun.WebPeis.Wechats;
using Microsoft.Extensions.Configuration;
using System.Net.Http;
using System.Net;
using System.Text.Json;
using Volo.Abp.Identity;
using Volo.Abp;
using Shentun.WebPeis.Enums;
using System.Net.Http.Headers;

using Microsoft.AspNetCore.Mvc;
using OpenIddict.Abstractions;
using Microsoft.AspNetCore.Identity;
using Volo.Abp.ObjectMapping;
using Microsoft.AspNetCore.Authorization;
using Volo.Abp.Caching;
using NPOI.SS.Formula.Functions;
using System.Linq.Dynamic.Core.Tokenizer;
using Microsoft.Extensions.Caching.Distributed;
using Volo.Abp.Uow;
using Scriban.Parsing;
using System.IdentityModel.Tokens.Jwt;
using Shentun.WebPeis.PatientRegisters;
using Microsoft.AspNetCore.Http;
using System.IO;
using Shentun.WebPeis.CustomerOrgs;
using Shentun.Utilities.Enums;
using Shentun.Sms.Client;
using Shentun.Utilities;
namespace Shentun.WebPeis.Persons
{
    /// <summary>
    /// 微信人员
    /// </summary>
    [ApiExplorerSettings(GroupName = "Work")]
    [Authorize]
    public class PersonAppService : ApplicationService
    {
        private readonly IRepository<QuestionRegister> _questionRegisterRepository;
        private readonly IConfiguration _configuration;
        private readonly IRepository<IdentityUser, Guid> _identityUserRepository;
        private readonly IdentityUserManager _userManager;
        private readonly IRepository<Person> _repository;
        private readonly PersonManager _personManager;
        private readonly IDistributedCache<string, string> _cache;
        private readonly IUnitOfWorkManager _unitOfWorkManager;
        private readonly IRepository<PersonKinship> _personKinshipRepository;
        private readonly IRepository<PatientRegister> _patientRegisterRepository;
        private readonly IRepository<Patient> _patientRepository;
        private readonly CacheService _cacheService;
        private readonly IHttpContextAccessor _httpContextAccessor;
        private readonly IRepository<CustomerOrg> _customerOrgRepository;
        public PersonAppService(IRepository<Person> repository,
             IConfiguration configuration,
             IRepository<Volo.Abp.Identity.IdentityUser, Guid> identityUserRepository,
             IdentityUserManager userManager,
             PersonManager personManager,
             IUnitOfWorkManager unitOfWorkManager,
             IDistributedCache<string, string> cache,
             IRepository<PersonKinship> personKinshipRepository,
             IRepository<PatientRegister> patientRegisterRepository,
             IRepository<Patient> patientRepository,
             CacheService cacheService,
             IHttpContextAccessor httpContextAccessor,
             IRepository<CustomerOrg> customerOrgRepository,
             IRepository<QuestionRegister> questionRegisterRepository)
        {
            _repository = repository;
            _configuration = configuration;
            _identityUserRepository = identityUserRepository;
            _userManager = userManager;
            _personManager = personManager;
            _unitOfWorkManager = unitOfWorkManager;
            _cache = cache;
            _personKinshipRepository = personKinshipRepository;
            _patientRegisterRepository = patientRegisterRepository;
            _patientRepository = patientRepository;
            _cacheService = cacheService;
            _httpContextAccessor = httpContextAccessor;
            _customerOrgRepository = customerOrgRepository;
            _questionRegisterRepository = questionRegisterRepository;
        }

        public async Task<PersonDto> GetByIdAsync(PersonIdInputDto input)
        {
            var entity = await _repository.GetAsync(o => o.PersonId == input.PersonId);
            var entityDto = ObjectMapper.Map<Person, PersonDto>(entity);

            return entityDto;

        }

        /// <summary>
        /// 微信用户登录
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [AllowAnonymous]
        [HttpPost("api/app/Person/WeChatUserLogin")]
        public async Task<UserTokenDto> WeChatUserLoginAsync(WechatUserJsCodeInputDto input)
        {

            var weChatClientId = _configuration.GetSection("AuthServer").GetSection("WeChatClientId").Value;
            var secret = _configuration.GetSection("AuthServer").GetSection("WeChatClientSecret").Value;
            var commonScopes = new List<string> {
            OpenIddictConstants.Permissions.Scopes.Address,
            OpenIddictConstants.Permissions.Scopes.Email,
            OpenIddictConstants.Permissions.Scopes.Phone,
            OpenIddictConstants.Permissions.Scopes.Profile,
            OpenIddictConstants.Permissions.Scopes.Roles,
            "WebPeis"
            };

            var dic = new Dictionary<string, object>
                {
                    {"jsCode",input.JsCode},
                    {"client_id",weChatClientId},
                    {"client_secret",secret},
                    {"grant_type",WeChatGrant.GrantType},
                    {"scope","WeChat offline_access"}
                };

            var dicStr = dic.Select(m => m.Key + "=" + m.Value).DefaultIfEmpty().Aggregate((m, n) => m + "&" + n);
            var token = await GetTokenAsync(dicStr);
            var options = new DistributedCacheEntryOptions()
                   .SetAbsoluteExpiration(TimeSpan.FromDays(3));
            var sessionKey = CacheKeys.SessionKey + Guid.NewGuid().ToString();
            var sessionKeyValue = Guid.NewGuid().ToString();
            _cache.Set(sessionKey, sessionKeyValue, options);
            token.SessionKey = sessionKey;
            token.SessionKeyValue = sessionKeyValue;

            return token;

        }

        [AllowAnonymous]
        [HttpPost("api/app/Person/Create")]
        [UnitOfWork(IsDisabled = false)]
        public async Task<UserTokenDto> CreateAsync(CreatePersonDto input)
        {
            if(input == null) throw new UserFriendlyException("input参数不能为空");

            using (var unitOfWork = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: true))
            {
                var entity = ObjectMapper.Map<CreatePersonDto, Person>(input);
                if (string.IsNullOrWhiteSpace(input.JsCode))
                {
                    throw new UserFriendlyException("jsCode不能为空");
                }
                if (string.IsNullOrWhiteSpace(input.WechatOpenId))
                {
                    throw new UserFriendlyException("WechatOpenId不能为空");
                }
                if (_cache.Get(CacheKeys.OpenIdKey + input.WechatOpenId) != input.WechatOpenId)
                {
                    throw new UserFriendlyException("无效的WechatOpenId");
                }
                if (string.IsNullOrWhiteSpace(input.MobileTelephone))
                {
                    throw new UserFriendlyException("手机号码不能为空");
                }
                if (input.MobileTelephone.Length != 11)
                {
                    throw new UserFriendlyException("手机号码必须为11位");
                }

                if (string.IsNullOrWhiteSpace(input.SmsVerifyCodeKey))
                {
                    throw new UserFriendlyException("短信校验码键不能为空");
                }

                if (_cache.Get(input.SmsVerifyCodeKey) != input.SmsVerifyCode)
                {
                    throw new UserFriendlyException("无效的短信校验码或已过期");
                }

                var person = await _repository.FindAsync(o => o.IdNo == input.IdNo);
                if (person != null)
                {
                    var user = (await _identityUserRepository.GetQueryableAsync()).Where(o => o.Id == person.PersonId &&
                       o.PhoneNumber == input.MobileTelephone).FirstOrDefault();
                    if (user == null)
                    {
                        throw new UserFriendlyException("该身份证号已注册，但手机号码不一致");
                    }
                    if (!string.IsNullOrWhiteSpace(person.WechatOpenId))
                    {
                        throw new UserFriendlyException("该微信号已注册");
                    }
                    person.WechatOpenId = input.WechatOpenId;
                    await _repository.UpdateAsync(person);
                }
                else
                {
                    entity.WechatOpenId = input.WechatOpenId;

                    var userWithPerson = await _personManager.CreateAsync(entity, input.PersonName,
                        input.Email, input.MobileTelephone);

                    await _identityUserRepository.InsertAsync(userWithPerson.User);
                    await _repository.InsertAsync(userWithPerson.Person);

                    //设置密码
                    (await _userManager.RemovePasswordAsync(userWithPerson.User)).CheckErrors();
                    (await _userManager.AddPasswordAsync(userWithPerson.User, Shentun.Utilities.
                        Encrypt.RandomHelper.CreateRandom(Utilities.Enums.RandomType.NumAndChar, 10) + "0Cz*")).CheckErrors();


                }

                await unitOfWork.CompleteAsync();
            }

            using (var unitOfWork = _unitOfWorkManager.Begin(requiresNew: true, isTransactional: false))
            {

                var weChatClientId = _configuration.GetSection("AuthServer").GetSection("WeChatClientId").Value;
                var secret = _configuration.GetSection("AuthServer").GetSection("WeChatClientSecret").Value;
                var dic = new Dictionary<string, object>
                {
                    {"jsCode",input.JsCode},
                    {"client_id",weChatClientId},
                    {"client_secret",secret},
                    {"grant_type",WeChatGrant.GrantType},
                    {"scope","WeChat offline_access"}
                };

                var dicStr = dic.Select(m => m.Key + "=" + m.Value).DefaultIfEmpty().Aggregate((m, n) => m + "&" + n);
                var token = await GetTokenAsync(dicStr);
                //var entityDto = ObjectMapper.Map<Person, PersonDto>(userWithPerson.Person);
                await unitOfWork.CompleteAsync();
                return token;
            }

        }

        /// <summary>
        /// 更新
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="UserFriendlyException"></exception>
        [HttpPost("api/app/Person/Update")]
        public async Task<PersonDto> UpdateAsync(UpdatePersonDto input)
        {
            if (input == null) throw new UserFriendlyException("input参数不能为空");

            var entity = ObjectMapper.Map<UpdatePersonDto, Person>(input);

            if (string.IsNullOrWhiteSpace(input.MobileTelephone))
            {
                throw new UserFriendlyException("手机号码不能为空");
            }
            if (input.MobileTelephone.Length != 11)
            {
                throw new UserFriendlyException("手机号码必须为11位");
            }

            if (string.IsNullOrWhiteSpace(input.SmsVerifyCodeKey))
            {
                throw new UserFriendlyException("短信校验码键不能为空");
            }

            if (_cache.Get(input.SmsVerifyCodeKey) != input.SmsVerifyCode)
            {
                throw new UserFriendlyException("无效的短信校验码或已过期");
            }
            //更新人员信息
            var person = await _repository.GetAsync(o =>o.PersonId == input.PersonId);
            await _personManager.UpdateAsync(entity, person);
            await _repository.UpdateAsync(person);
            //更新用户信息
            var user = await _identityUserRepository.GetAsync(person.PersonId);
            user.Name = input.PersonName;
            user.SetPhoneNumber(input.MobileTelephone,false);
            await _identityUserRepository.UpdateAsync(user);
            
            return ObjectMapper.Map<Person, PersonDto>(person);

        }
        /// <summary>
        /// 创建亲属
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="UserFriendlyException"></exception>
        [HttpPost("api/app/Person/CreatePersonKinship")]
        public async Task CreatePersonKinshipAsync(CreatePersonKinshipDto input)
        {
            if (input == null) throw new UserFriendlyException("input参数不能为空");
            var entity = ObjectMapper.Map<CreatePersonKinshipDto, Person>(input);
            if (string.IsNullOrWhiteSpace(input.KinshipId))
            {
                throw new UserFriendlyException("亲属关系不能为空");
            }

            if (string.IsNullOrWhiteSpace(input.SmsVerifyCodeKey))
            {
                throw new UserFriendlyException("短信校验码键不能为空");
            }

            if (_cache.Get(input.SmsVerifyCodeKey) != input.SmsVerifyCode)
            {
                throw new UserFriendlyException("无效的短信校验码或已过期");
            }

            var person = await _repository.FindAsync(o => o.IdNo == input.IdNo);
            if (person != null)
            {
                var user = (await _identityUserRepository.GetQueryableAsync()).Where(o => o.Id == person.PersonId &&
                   o.PhoneNumber == input.MobileTelephone).FirstOrDefault();
                if (user == null)
                {
                    throw new UserFriendlyException("该身份证号已注册，但手机号码不一致");
                }
                var personKinshipExist = new PersonKinship()
                {
                    PersonId = person.PersonId,
                    ParentPersonId = (Guid)CurrentUser.Id,
                    KinshipId = input.KinshipId,
                };
                await _personKinshipRepository.InsertAsync(personKinshipExist);
                return;
            }



            var userWithPerson = await _personManager.CreateAsync(entity, input.PersonName,
                input.Email, input.MobileTelephone);

            var personKinship = new PersonKinship()
            {
                PersonId = userWithPerson.Person.PersonId,
                ParentPersonId = (Guid)CurrentUser.Id,
                KinshipId = input.KinshipId,
            };

            await _identityUserRepository.InsertAsync(userWithPerson.User);
            await _repository.InsertAsync(userWithPerson.Person);
            await _personKinshipRepository.InsertAsync(personKinship);

            //设置密码
            (await _userManager.RemovePasswordAsync(userWithPerson.User)).CheckErrors();
            (await _userManager.AddPasswordAsync(userWithPerson.User, Shentun.Utilities.
                Encrypt.RandomHelper.CreateRandom(Utilities.Enums.RandomType.NumAndChar, 10) + "0Cz*")).CheckErrors();


        }

        /// <summary>
        /// 取消人员绑定
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/Person/CancelPersonKinship")]
        public async Task CancelPersonKinshipAsync(PersonIdInputDto input)
        {
            var personKinship = await _personKinshipRepository.GetAsync(o => o.ParentPersonId == (Guid)CurrentUser.Id && o.PersonId == input.PersonId);
            await _personKinshipRepository.DeleteAsync(personKinship);

        }
        /// <summary>
        /// 获取体检次数列表
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        [HttpPost("api/app/Person/GetMedicalTimesListByPersonId")]
        public async Task<List<PersonMedicalTimesDto>> GetMedicalTimesListByPersonIdAsync(PersonIdInputDto input)
        {

            var entityList = (from user in await _identityUserRepository.GetQueryableAsync()
                              join person in await _repository.GetQueryableAsync()
                              on user.Id equals person.PersonId
                              join patient in await _patientRepository.GetQueryableAsync()
                              on new { idNo = person.IdNo, phone = user.PhoneNumber } equals new { idNo = patient.IdNo, phone = patient.MobileTelephone }
                              join patientRegister in await _patientRegisterRepository.GetQueryableAsync()
                              on patient.PatientId equals patientRegister.PatientId
                              where user.Id == input.PersonId &&
                              (patientRegister.CompleteFlag == PatientRegisterCompleteFlag.SumCheck)
                              orderby patientRegister.MedicalStartDate
                              select new PersonMedicalTimesDto()
                              {
                                  PatientRegisterId = patientRegister.PatientRegisterId,
                                  PersonName = patient.PatientName,
                                  MedicalStartDate = patientRegister.MedicalStartDate,
                              }).ToList();
            return entityList;

        }

        /// <summary>
        /// 获取本人和亲属列表
        /// </summary>
        /// <returns></returns>
        [HttpPost("api/app/Person/GetPersonKinshipList")]
        public async Task<List<PersonDto>> GetPersonKinshipList()
        {
            var personKinshipIds = (await _personKinshipRepository.GetQueryableAsync())
                .Where(o => o.ParentPersonId == CurrentUser.Id)
                .Select(o => o.PersonId).ToList();
            personKinshipIds.Add((Guid)CurrentUser.Id);
            var personList = (from user in await _identityUserRepository.GetQueryableAsync()
                              join person in await _repository.GetQueryableAsync()
                              on user.Id equals person.PersonId
                              join questionRegister in await _questionRegisterRepository.GetQueryableAsync()
                              on person.PersonId equals questionRegister.PersonId into emptyQuestionRegister
                              from haveQuestionRegister in emptyQuestionRegister.DefaultIfEmpty()
                              where personKinshipIds.Contains(user.Id)
                              orderby user.CreationTime
                              select new PersonDto
                              {
                                  PersonId = user.Id,
                                  PersonNo = person.PersonNo,
                                  MedicalCenterId = person.MedicalCenterId,
                                  PersonName = user.Name,
                                  SexId = person.SexId,
                                  SexName = _cacheService.GetSexNameAsync(person.SexId).Result,
                                  MaritalStatusId = person.MaritalStatusId,
                                  MaritalStatusName = _cacheService.GetMaritalStatusNameAsync(person.MaritalStatusId).Result,
                                  BirthDate = person.BirthDate,
                                  NationId = person.NationId,
                                  NationName = _cacheService.GetNationNameAsync(person.NationId).Result,
                                  BirthPlaceId = person.BirthPlaceId,
                                  IdNo = person.IdNo,
                                  PostalCode = person.PostalCode,
                                  Email = user.Email,
                                  MobileTelephone = user.PhoneNumber,
                                  Address = person.Address,
                                  IdTypeId = person.IdTypeId,
                                  CountryCode = person.CountryCode,
                                  IsAllowBind = person.IsAllowBind,
                                  IsHaveQuestionRegister = haveQuestionRegister == null ? 'N' : 'Y',
                                  Height = person.Height,
                                  Weight = person.Weight


                              }).Distinct().ToList();
            for (var i = 0; i < personList.Count; i++)
            {
                personList[i].DisplayOrder = i + 1;
                if (personList[i].PersonId == CurrentUser.Id)
                {
                    personList[i].DisplayOrder = 0; //本人强行排第一个
                }
            }
            personList = personList.OrderBy(o => o.DisplayOrder).ToList();
            return personList;
        }
        /// <summary>
        /// 获取PDF体检报告
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="UserFriendlyException"></exception>
        [HttpPost("api/app/Person/GetMedicalReportByPatientRegisterId")]
        public async Task<MedicalReportDto> GetMedicalReportByPatientRegisterIdAsync(PatientRegisterIdInputDto input)
        {
            var entity = await _patientRegisterRepository.GetAsync(o => o.PatientRegisterId == input.PatientRegisterId);
            if (string.IsNullOrWhiteSpace(entity.ReportFile))
            {
                throw new UserFriendlyException("没有报告单");
            }
            var Host = $"{_httpContextAccessor.HttpContext.Request.Scheme}://{_httpContextAccessor.HttpContext.Request.Host.Host}:{_httpContextAccessor.HttpContext.Request.Host.Port}";
            var returnValue = new MedicalReportDto()
            {
                FilePath = entity.ReportFile,
                FileBase64 = Shentun.Utilities.FileHelper.ToBase64(Host + entity.ReportFile)
            };
            return returnValue;

        }


        /// <summary>
        /// 获取健康评估报告
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="UserFriendlyException"></exception>
        [HttpPost("api/app/Person/GetMedicalHealthReportByPatientRegisterId")]
        public async Task<MedicalReportDto> GetMedicalHealthReportByPatientRegisterIdAsync(PatientRegisterIdInputDto input)
        {
            var entity = await _patientRegisterRepository.GetAsync(o => o.PatientRegisterId == input.PatientRegisterId);
            string baseAddress = _configuration.GetSection("MedicalHealthReport").GetSection("BaseAddress").Value;
            string reportListApiUrl = _configuration.GetSection("MedicalHealthReport").GetSection("ReportListApiUrl").Value;
            string reportApiUrl = _configuration.GetSection("MedicalHealthReport").GetSection("ReportApiUrl").Value;

            var medicalHealthReportListInputDto = new MedicalHealthReportListInputDto
            {
                Page = 1,
                Size = 10,
                RecordNo = entity.PatientRegisterNo
            };

            var medicalHealthReportListResult = await CallAppServiceAsync<MedicalHealthReportListInputDto, MedicalHealthReportListDto>(baseAddress, reportListApiUrl, medicalHealthReportListInputDto, "post");

            if (medicalHealthReportListResult.Code != 200
                || medicalHealthReportListResult.Data.FirstOrDefault() == null
                || medicalHealthReportListResult.Data.FirstOrDefault().ReportStatus != "1")
            {
                throw new UserFriendlyException("没有健康评估报告");
            }

            //报告单ID
            var resultId = medicalHealthReportListResult.Data.FirstOrDefault().ResultId;

            reportApiUrl = reportApiUrl + $"?resultId={resultId}"; //获取报告apiurl

            var medicalHealthReportResult = await CallAppServiceAsync<MedicalHealthReportDto, MedicalHealthReportDto>(baseAddress, reportApiUrl, null, "get");
            if (medicalHealthReportResult.Code != 200
                || string.IsNullOrWhiteSpace(medicalHealthReportResult.Data)
                )
            {
                throw new UserFriendlyException("没有健康评估报告");
            }

            string reportUrl = medicalHealthReportResult.Data;


            if (reportUrl.IndexOf(baseAddress) == -1)
            {
                //替换路径为代理地址
                reportUrl = reportUrl.Replace("http://", "").Replace("https://", "");
                reportUrl = baseAddress + reportUrl.Substring(reportUrl.IndexOf('/'));
            }
            var returnValue = new MedicalReportDto()
            {
                FilePath = reportUrl,
                FileBase64 = Shentun.Utilities.FileHelper.ToBase64(reportUrl)
            };
            return returnValue;

        }

        /// <summary>
        /// 获取校验码
        /// </summary>
        /// <param name="input"></param>
        /// <returns></returns>
        /// <exception cref="UserFriendlyException"></exception>
        [AllowAnonymous]
        [HttpPost("api/app/Person/GetSmsVerifyCode")]
        public async Task<SmsVerifyCodeDto> GetSmsVerifyCodeAsync(SmsVerifyCodeInputDto input)
        {
            if (input == null)
            {
                throw new UserFriendlyException("input不能为空");
            }
            //if (string.IsNullOrWhiteSpace(input.WechatOpenId))
            //{
            //    throw new UserFriendlyException("WechatOpenId不能为空");
            //}
            //if (_cache.Get(CacheKeys.OpenIdKey + input.WechatOpenId) != input.WechatOpenId)
            //{
            //    throw new UserFriendlyException("无效的WechatOpenId");
            //}

            if (string.IsNullOrWhiteSpace(input.SessionKey))
            {
                throw new UserFriendlyException("SessionKey不能为空");
            }
            if (_cache.Get(input.SessionKey) != input.SessionKeyValue)
            {
                throw new UserFriendlyException("无效的SessionKeyValue");
            }

            if (string.IsNullOrWhiteSpace(input.PersonName))
            {
                throw new UserFriendlyException("姓名不能为空");
            }

            if (string.IsNullOrWhiteSpace(input.MobileTelephone))
            {
                throw new UserFriendlyException("手机号码不能为空");
            }
            if (input.MobileTelephone.Length != 11)
            {
                throw new UserFriendlyException("手机号码必须为11位");
            }
            if (string.IsNullOrWhiteSpace(input.IdNo))
            {
                throw new UserFriendlyException("身份证号码不能为空");
            }
            input.IdNo = input.IdNo.Trim();
            if (input.IdNo.Length != 18)
            {
                throw new UserFriendlyException("身份证长度必须为18位");
            }
            //var sexByIdNo = ConvertExtr.ToSexByIdNo(idNo).ToCharArray();
            if (input.PersonId == null || input.PersonId == default(Guid))
            {
                var person = await _repository.FindAsync(o => o.IdNo == input.IdNo);
                if (person != null)
                {
                    var user = (await _identityUserRepository.GetQueryableAsync()).Where(o => o.Id == person.PersonId &&
                       o.PhoneNumber == input.MobileTelephone).FirstOrDefault();
                    if (user == null)
                    {
                        throw new UserFriendlyException("该身份证号已注册，但手机号码不一致");
                    }
                    //if (!string.IsNullOrWhiteSpace(person.WechatOpenId))
                    //{
                    //    throw new UserFriendlyException("该微信号已注册");
                    //}
                }
            }



            var createSmsTaskDto = new CreateSmsTaskDto()
            {
                PersonId = "0001",
                PersonName = input.PersonName,
                MobileTelephone = input.MobileTelephone,
                CountryCode = "86",
            };

            var smsVerifyCodeKey = await SendVerifySms(createSmsTaskDto);
            var SmsVerifyCodeDto = new SmsVerifyCodeDto()
            {
                SmsVerifyCodeKey = smsVerifyCodeKey
            };

            return SmsVerifyCodeDto;

        }

        private async Task<UserTokenDto> GetTokenAsync(string request)
        {
            using var client = new HttpClient();
            HttpContent httpContent = new StringContent(request);
            httpContent.Headers.ContentType = new MediaTypeHeaderValue("application/x-www-form-urlencoded");
            var url = _configuration.GetSection("AuthServer").
                GetSection("Authority").Value + "/connect/token";
            var tokenResult = await client.PostAsync(url
                , httpContent);
            var tokenResultStr = await tokenResult.Content.ReadAsStringAsync();
            if (tokenResult.IsSuccessStatusCode)
            {

                if (!string.IsNullOrEmpty(tokenResultStr))
                {
                    if (tokenResultStr.ToLower().Contains("openid"))
                    {
                        var wechatUserDto = JsonSerializer.Deserialize<WechatUserDto>(tokenResultStr,
                        new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
                        var userTokenDto = new UserTokenDto
                        {
                            IsNewUser = "Y",
                            OpenId = wechatUserDto.OpenId
                        };
                        var options = new DistributedCacheEntryOptions()
                         .SetAbsoluteExpiration(TimeSpan.FromDays(3));
                        _cache.Set(CacheKeys.OpenIdKey + wechatUserDto.OpenId,
                            wechatUserDto.OpenId, options);

                        return userTokenDto;
                    }
                    else
                    {
                        var signResult = JsonSerializer.Deserialize<SignInResultDto>(tokenResultStr,
                       new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });
                        var userTokenDto = new UserTokenDto
                        {
                            IsNewUser = "N",
                            AccessToken = signResult.access_token,
                            RefreshToken = signResult.refresh_token
                        };

                        return userTokenDto;
                    }

                }
                else
                {
                    throw new UserFriendlyException("token值为空");
                }

            }
            else
            {
                //tokenResultStr = tokenResultStr.Replace("<", "").Replace(">", "");
                //var grantErrorDto = JsonSerializer.Deserialize<GrantErrorDto>(tokenResultStr,
                //      new JsonSerializerOptions() { PropertyNameCaseInsensitive = true });

                throw new UserFriendlyException("获取token失败:" + tokenResultStr);
            }
        }


        public async Task<string> SendVerifySms(CreateSmsTaskDto createSmsTaskDto)
        {
            if (createSmsTaskDto == null)
            {
                throw new UserFriendlyException("createSmsTaskDto参数不能为空");
            }

            var message = Shentun.Utilities.Encrypt.RandomHelper.CreateRandom(Utilities.Enums.RandomType.Num, 6);

            var verifySmsValidTimeStr = _configuration.GetSection("Sms")
              .GetSection("VerifySmsValidTime").Value;
            if (!int.TryParse(verifySmsValidTimeStr, out var verifySmsValidTime))
            {
                throw new Exception("解析校验短信有效时间错误");
            }

            createSmsTaskDto.Content = message + "|" + verifySmsValidTime.ToString();
            //发送短信
            createSmsTaskDto.TaskCycleType = '0';
            await SmsClientHelper.CreateVerifySmsTask(createSmsTaskDto);
            //存储短信校验码
            var options = new DistributedCacheEntryOptions()
            .SetAbsoluteExpiration(TimeSpan.FromMinutes(verifySmsValidTime));
            var smsVerifyCodeKey = CacheKeys.SmsKey + createSmsTaskDto.MobileTelephone + Guid.NewGuid().ToString();
            _cache.Set(smsVerifyCodeKey, message, options);
            return smsVerifyCodeKey;
        }


        private async static Task<TOut> CallAppServiceAsync<TInput, TOut>(string baseAddress, string url, TInput? data, string method = "post")
        {

            using (var httpClientHandler = new HttpClientHandler())
            {
                using (var httpClient = new HttpClient(httpClientHandler))
                {
                    httpClient.BaseAddress = new Uri(baseAddress);

                    httpClient.DefaultRequestHeaders.Accept.Add(
                      new MediaTypeWithQualityHeaderValue("application/json"));//设置accept标头，告诉JSON是可接受的响应类型

                    var jsonOptions = new JsonSerializerOptions
                    {
                        WriteIndented = true, // 设置为true以便于可读性更好的JSON输出
                        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
                        // 如果你想要对日期进行格式化，可以使用JsonConverter
                        Converters = { new JsonDateTimeConverter("yyyy-MM-dd HH:mm:ss") }
                    };
                    var sendData = System.Text.Json.JsonSerializer.Serialize(data, jsonOptions);
                    using (HttpContent httpContent = new StringContent(sendData))
                    {
                        httpContent.Headers.ContentType = new MediaTypeHeaderValue("application/json");
                        HttpResponseMessage response = null;
                        if (method == "post")
                        {
                            response = await httpClient.PostAsync(url, httpContent);
                        }
                        else
                        {
                            response = await httpClient.GetAsync(url);
                        }

                        string result;
                        if (!response.IsSuccessStatusCode)
                        {
                            result = response.Content.ReadAsStringAsync().Result;
                            throw new Exception("http通信错误:" + response.StatusCode + ",结果:" + result);
                        }
                        result = await response.Content.ReadAsStringAsync();

                        var resultDto = System.Text.Json.JsonSerializer.Deserialize<TOut>(result, jsonOptions);

                        return resultDto;
                    }

                }
            }
        }

    }
}