EntrustSettle/EntrustSettle.Services/HYDService.cs

using EntrustSettle.Common;
using EntrustSettle.Common.Caches;
using EntrustSettle.Common.Const;
using EntrustSettle.IServices;
using EntrustSettle.Model;
using EntrustSettle.Model.Dtos;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.Extensions.Logging;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using NLog;
using RestSharp;
using System;
using System.Collections.Generic;
using System.Threading.Tasks;
using ILogger = Microsoft.Extensions.Logging.ILogger;

namespace EntrustSettle.Services
{
    public class HYDService : IHYDService
    {
        private readonly ICaching caching;
        private readonly ILogger logger;
        private readonly IRestClient client;

        public HYDService(ICaching caching,
                          //ILoggerFactory logFactory,
                          ILogger<HYDService> logger,
                          [FromKeyedServices(HttpEnum.Hyd)] IRestClient client)
        {
            this.caching = caching;
            this.client = client;
            //logger = logFactory.CreateLogger("BigDataLogger");
            this.logger = logger;
        }
        public async Task<long> Submit(HydSubmitDto submitDto)
        {
            try
            {
                string token = await GetToken();

                var url = AppSettings.app("Apis", "Hyd", "SubmitUrl");
                var customer = AppSettings.app("Apis", "Hyd", "CUSTOMER");
                var headers = new Dictionary<string, string>()
                {
                    { "PDK", token },
                    { "CUSTOMER", customer }
                };
                var request = new RestRequest(url);
                request.AddHeaders(headers);
                request.AddJsonBody(submitDto);

                var resp = await client.ExecutePostAsync(request);  // 以Execute开头的方法不会引发异常
                logger.LogRestSharp("海运达下单接口", client, request, resp);

                if (resp.IsSuccessful)
                {
                    var jobj = JObject.Parse(resp.Content);
                    var code = jobj.GetValue("code").ObjToInt();
                    if (code == 200)
                    {
                        var bsno = jobj.GetValue("data").ObjToLong();
                        return bsno;
                    }
                    else
                    {
                        if (code > 400 && code < 500)
                        {
                            await caching.DelCacheKeyAsync(CacheConst.HydAccessToken);
                        }
                    }
                }
                throw new Exception("调用外部下单接口失败");
            }
            catch (Exception ex)
            {
                throw new Exception("下单失败，原因：" + ex.Message);
            }
        }

        public async Task<List<HydQueryResultDto>> Query(string mblno)
        {
            string token = await GetToken();

            var url = AppSettings.app("Apis", "Hyd", "QueryUrl");
            var customer = AppSettings.app("Apis", "Hyd", "CUSTOMER");
            var headers = new Dictionary<string, string>()
            {
                { "PDK", token },
                { "CUSTOMER", customer }
            };
            string[] param = [mblno];

            var request = new RestRequest(url);
            request.AddHeaders(headers);
            request.AddJsonBody(param);

            var resp = await client.ExecuteGetAsync(request);  // 以Execute开头的方法不会引发异常
            logger.LogRestSharp("海运达状态查询接口", client, request, resp);

            if (resp.IsSuccessful)
            {

                var jobj = JObject.Parse(resp.Content);
                var code = jobj.GetValue("code").ObjToInt();
                if (code == 200)
                {
                    var result = JsonConvert.DeserializeObject<List<HydQueryResultDto>>(jobj.GetValue("rows").ToString());
                    return result;
                }
                else
                {
                    if (code > 400 && code < 500)
                    {
                        await caching.DelCacheKeyAsync(CacheConst.HydAccessToken);
                    }
                }
            }
            throw new Exception("调用外部状态查询接口失败");
        }
        public async Task<bool> FeedBack(List<HydFeedbackDto> hydFeedbackDtoList)
        {
            try
            {
                string token = await GetToken();

                var url = AppSettings.app("Apis", "Hyd", "FeedbackUrl");
                var customer = AppSettings.app("Apis", "Hyd", "CUSTOMER");
                var headers = new Dictionary<string, string>()
                {
                    { "PDK", token },
                    { "CUSTOMER", customer }
                };
                foreach (var item in hydFeedbackDtoList)
                {
                    var request = new RestRequest(url);
                    request.AddHeaders(headers);
                    request.AddJsonBody(item);

                    var resp = await client.ExecutePostAsync(request);  // 以Execute开头的方法不会引发异常
                    logger.LogRestSharp("海运达反馈接口", client, request, resp);

                    if (resp.IsSuccessful)
                    {
                        var jobj = JObject.Parse(resp.Content);
                        var code = jobj.GetValue("code").ObjToInt();
                        if (code == 200)
                        {
                            continue;
                        }
                        else
                        {
                            if (code > 400 && code < 500)
                            {
                                await caching.DelCacheKeyAsync(CacheConst.HydAccessToken);
                            }
                            var msg = jobj.GetValue("msg").ToString();
                        }
                    }
                    throw new Exception("调用外部反馈接口失败");
                }

                return true;
            }
            catch (Exception ex)
            {
                throw new Exception("反馈失败，原因：" + ex.Message);
            }
        }

        private async Task<string> GetToken()
        {
            var token = await caching.GetAsync<string>(CacheConst.HydAccessToken);
            if (!string.IsNullOrEmpty(token))
            {
                return token;
            }

            var url = AppSettings.app("Apis", "Hyd", "LoginUrl");
            var request = new RestRequest(url);
            var body = new
            {
                username = AppSettings.app("Apis", "Hyd", "username"),
                password = AppSettings.app("Apis", "Hyd", "password")
            };
            request.AddJsonBody(body);

            var resp = await client.ExecutePostAsync(request);  // 以Execute开头的方法不会引发异常
            logger.LogRestSharp("海运达登录接口", client, request, resp);

            if (resp.IsSuccessful)
            {
                var jobj = JObject.Parse(resp.Content);
                var code = jobj.GetValue("code");
                if (code.ObjToInt() == 200)
                {
                    token = jobj.GetValue("token").ToString();
                    await caching.SetAsync(CacheConst.HydAccessToken, token, TimeSpan.FromHours(3));
                    return token;
                }
            }
            throw new Exception($"调用外部登录接口失败({resp.ErrorException?.InnerException?.Message})");
        }

    }
}