bbwy/BBWY.Server.Business/Sync/AfterSaleOrderSyncBusiness.cs

using BBWY.Common.Http;
using BBWY.Common.Models;
using BBWY.Server.Model;
using BBWY.Server.Model.Db;
using BBWY.Server.Model.Dto;
using FreeSql;
using Microsoft.Extensions.Options;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using NLog;
using System;
using System.Collections.Generic;
using System.Linq;
using System.Net.Http;
using System.Threading.Tasks;
using Yitter.IdGenerator;

namespace BBWY.Server.Business
{
    public class AfterSaleOrderSyncBusiness : BaseSyncBusiness, IDenpendency
    {
        private IDictionary<Enums.Platform, Action<JArray, ShopResponse>> syncAfterSaleOrderMethodDic;

        private IDictionary<int, Enums.ServiceResult> processResultDic;


        public AfterSaleOrderSyncBusiness(RestApiService restApiService,
                                          IOptions<GlobalConfig> options,
                                          ILogger logger,
                                          IFreeSql fsql,
                                          IIdGenerator idGenerator,
                                          TaskSchedulerManager taskSchedulerManager,
                                          VenderBusiness venderBusiness) : base(restApiService,
                                                                           options,
                                                                           logger,
                                                                           fsql,
                                                                           idGenerator,
                                                                           taskSchedulerManager,
                                                                           venderBusiness)
        {
            syncAfterSaleOrderMethodDic = new Dictionary<Enums.Platform, Action<JArray, ShopResponse>>()
            {
                { Enums.Platform.京东, SyncJDAfterOrder }
            };

            processResultDic = new Dictionary<int, Enums.ServiceResult>()
            {
                { 23,Enums.ServiceResult.换新},
                { 40,Enums.ServiceResult.退货},
                { 60,Enums.ServiceResult.原返},
                { 90,Enums.ServiceResult.线下换新},
            };
        }

        private void SyncJDAfterOrder(JArray afterOrderTokenJArray, ShopResponse shopResponse)
        {
            var shopId = long.Parse(shopResponse.ShopId);
            var validAfterOrderJArray = afterOrderTokenJArray.Where(j => j.Value<int>("serviceStatus") == 10010 &&   //完成
                                                                         j.Value<int>("processResult") != 100);      //不等于闪电催收收款

            var orderIds = validAfterOrderJArray.Select(j => j["orderId"].ToString()).Distinct().ToList();
            var orderSkuIds = validAfterOrderJArray.Select(j => j["skuId"].ToString()).Distinct().ToList();

            var updateOrders = fsql.Select<Order>().Where(o => orderIds.Contains(o.Id) && o.IsAfterSaleOrder == false).ToList();
            var updateOrderSkus = fsql.Select<OrderSku>().Where(osku => orderIds.Contains(osku.OrderId) &&
                                                                        orderSkuIds.Contains(osku.SkuId)).ToList();

            var afterOrders = fsql.Select<AfterSaleOrder>().Where(aso => orderIds.Contains(aso.OrderId)).ToList();

            List<AfterSaleOrder> insertAfterSaleOrders = new List<AfterSaleOrder>();
            List<IUpdate<AfterSaleOrder>> updateAfterSaleOrders = new List<IUpdate<AfterSaleOrder>>();

            foreach (var afterOrderJToken in validAfterOrderJArray)
            {
                var orderId = afterOrderJToken.Value<string>("orderId");
                var skuId = afterOrderJToken.Value<string>("skuId");

                var updateSku = updateOrderSkus.FirstOrDefault(osku => osku.OrderId == orderId && osku.SkuId == skuId);
                if (updateSku == null)
                    continue;

                var afterOrder = afterOrders.FirstOrDefault(aso => aso.OrderId == orderId && aso.SkuId == skuId);
                var processResult = processResultDic[afterOrderJToken.Value<int>("processResult")];
                if (afterOrder == null)
                {
                    insertAfterSaleOrders.Add(new AfterSaleOrder()
                    {
                        Id = idGenerator.NewLong(),
                        CreateTime = DateTime.Now,
                        OrderId = updateSku.OrderId,
                        ProductId = updateSku.ProductId,
                        RefundAmount = 0,
                        SkuId = skuId,
                        ShopId = shopId,
                        ServiceResult = processResult
                    });
                }
                else
                {
                    if (afterOrder.ServiceResult == null && afterOrder.ServiceResult != processResult)
                    {
                        var update = fsql.Update<AfterSaleOrder>(afterOrder.Id).Set(aso => aso.ServiceResult, processResult);
                        updateAfterSaleOrders.Add(update);
                    }
                }
            }

            fsql.Transaction(() =>
            {
                if (updateOrders.Count() > 0)
                    foreach (var updateOrder in updateOrders)
                        fsql.Update<Order>(updateOrder.Id).Set(o => o.IsAfterSaleOrder, true).ExecuteAffrows();

                if (insertAfterSaleOrders.Count() > 0)
                    fsql.Insert(insertAfterSaleOrders).ExecuteAffrows();
                if (updateAfterSaleOrders.Count() > 0)
                    foreach (var update in updateAfterSaleOrders)
                        update.ExecuteUpdated();
            });
        }


        private void SyncAfterOrder(ShopResponse shop, string orderId, DateTime? startTime = null, DateTime? endTime = null, bool isAuto = false)
        {
            try
            {
                logger.Info($"售后订单同步 {shop.ShopName} isAuto {isAuto}");
                if (!syncAfterSaleOrderMethodDic.ContainsKey(shop.PlatformId))
                    throw new Exception("不支持的平台");
                var shopId = long.Parse(shop.ShopId);
                var relayAPIHost = GetPlatformRelayAPIHost(shop.PlatformId);
                var afterOrderListApiResult = restApiService.SendRequest(relayAPIHost, "api/PlatformSDK/GetAfterOrderList", new SyncAfterOrderRequest()
                {
                    StartDate = startTime ?? DateTime.Now.Date.AddDays(-1),
                    EndDate = endTime ?? DateTime.Now,
                    AppKey = shop.AppKey,
                    AppSecret = shop.AppSecret,
                    AppToken = shop.AppToken,
                    PageIndex = 1,
                    PageSize = 50,
                    Platform = shop.PlatformId,
                    SaveResponseLog = true,
                    OrderId = orderId,
                    VenderId = shop.VenderId
                }, null, HttpMethod.Post);
                if (afterOrderListApiResult.StatusCode != System.Net.HttpStatusCode.OK)
                    throw new Exception($"获取退款订单失败 {afterOrderListApiResult.Content}");

                var afterOrderListResponse = JsonConvert.DeserializeObject<ApiResponse<JArray>>(afterOrderListApiResult.Content);
                if (!afterOrderListResponse.Success)
                    throw new Exception($"获取退款订单失败 {afterOrderListApiResult.Content}");

                if (afterOrderListResponse.Data == null || afterOrderListResponse.Data.Count == 0)
                    return;

                syncAfterSaleOrderMethodDic[shop.PlatformId](afterOrderListResponse.Data, shop);
            }
            catch (Exception ex)
            {
                var shopData = JsonConvert.SerializeObject(shop);
                logger.Error(ex, $"SyncAfterOrder ShopData:{shopData}");
            }
        }

        public void SyncAllShopAfterOrder()
        {
            var shopList = venderBusiness.GetShopList();
            //SyncAfterOrder(shopList.FirstOrDefault(s => s.ShopName == "布莱特玩具专营店"), string.Empty, isAuto: true);
            foreach (var shop in shopList)
            {
                Task.Factory.StartNew(() => SyncAfterOrder(shop, string.Empty, isAuto: true),
                                            System.Threading.CancellationToken.None,
                                            TaskCreationOptions.LongRunning,
                                            taskSchedulerManager.SyncAfterOrderTaskScheduler);
            }
        }
    }
}