bbwy/BBWY.Server.Business/BillCorrection/BillCorrectionBusiness.cs

using BBWY.Common.Models;
using BBWY.Server.Model.Db;
using BBWY.Server.Model.Dto;
using System.Collections.Generic;
using Yitter.IdGenerator;
using System.Linq;
using FreeSql;
using BBWY.Server.Business.Extensions;

namespace BBWY.Server.Business
{
    public class BillCorrectionBusiness : BaseBusiness, IDenpendency
    {
        public BillCorrectionBusiness(IFreeSql fsql, NLogManager nLogManager, IIdGenerator idGenerator) : base(fsql, nLogManager, idGenerator)
        {

        }

        public IList<BillCorrectionOrderResponse> GetBillCorrectionOrderList(QueryBillCorrectionOrderRequest request)
        {
            request.EndTime = request.EndTime.Date.AddDays(1).AddSeconds(-1);
            var orderList = fsql.Select<Order>()
                                .Where(o => request.ShopIds.Contains(o.ShopId) && o.StartTime >= request.StartTime && o.StartTime <= request.EndTime)
                                .OrderBy(o => o.StartTime)
                                .ToList(o => new BillCorrectionOrderResponse
                                {
                                    OrderId = o.Id,
                                    StartTime = o.StartTime,
                                    StorageType = o.StorageType,
                                    OrderState = o.OrderState,
                                    WaybillNo = o.WaybillNo,
                                    ShopId = o.ShopId
                                });

            var orderIds = orderList.Select(o => o.OrderId).ToList();
            var sdOrderIds = orderList.Where(o => o.StorageType == Model.Enums.StorageType.SD).Select(o => o.OrderId).ToArray();

            var orderCostDetailList = fsql.Select<OrderCostDetail>()
                                          .Where(ocd => orderIds.Contains(ocd.OrderId) && ocd.IsEnabled == true)
                                          .GroupBy(ocd => ocd.OrderId)
                                          .ToList(g => new
                                          {
                                              OrderId = g.Key,
                                              DeliveryExpressFreight = g.Sum(g.Value.DeliveryExpressFreight),
                                              SkuAmount = g.Sum(g.Value.SkuAmount),
                                              PurchaseFreight = g.Sum(g.Value.PurchaseFreight),
                                              FirstFreight = g.Sum(g.Value.FirstFreight),
                                              InStorageAmount = g.Sum(g.Value.InStorageAmount),
                                              OutStorageAmount = g.Sum(g.Value.OutStorageAmount),
                                              ConsumableAmount = g.Sum(g.Value.ConsumableAmount),
                                              StorageAmount = g.Sum(g.Value.StorageAmount)
                                          });

            var sdOrderCostList = fsql.Select<OrderCost>(sdOrderIds).ToList();

            var afterOrderList = fsql.Select<AfterSaleOrder>()
                                     .Where(aso => orderIds.Contains(aso.OrderId))
                                     .GroupBy(aso => aso.OrderId)
                                     .ToList(g => new
                                     {
                                         OrderId = g.Key,
                                         AfterTotalCost = g.Sum(g.Value.AfterTotalCost)
                                     });

            foreach (var order in orderList)
            {
                var orderCostDetail = orderCostDetailList.FirstOrDefault(ocd => ocd.OrderId == order.OrderId);
                var afterOrder = afterOrderList.FirstOrDefault(aso => aso.OrderId == order.OrderId);

                order.DeliveryExpressFreight = orderCostDetail?.DeliveryExpressFreight ?? 0M;
                order.SkuAmount = orderCostDetail?.SkuAmount ?? 0M;
                order.PurchaseFreight = orderCostDetail?.PurchaseFreight ?? 0M;
                order.FirstFreight = orderCostDetail?.FirstFreight ?? 0M;
                order.InStorageAmount = orderCostDetail?.InStorageAmount ?? 0M;
                order.OutStorageAmount = orderCostDetail?.OutStorageAmount ?? 0M;
                order.ConsumableAmount = orderCostDetail?.ConsumableAmount ?? 0M;
                order.StorageAmount = orderCostDetail?.StorageAmount ?? 0M;
                order.AfterTotalCost = afterOrder?.AfterTotalCost ?? 0M;

                if (order.StorageType == Model.Enums.StorageType.SD)
                {
                    var sdOrderCost = sdOrderCostList.FirstOrDefault(oc => oc.OrderId == order.OrderId);
                    order.DeliveryExpressFreight = sdOrderCost?.DeliveryExpressFreight ?? 0M;
                }

            }
            return orderList;
        }

        public void CorrectOrder(IList<BillCorrectionRequest> requestList)
        {
            var orderIds = requestList.Select(r => r.OrderId).ToArray();

            var orderList = fsql.Select<Order>(orderIds).ToList();
            var orderCostList = fsql.Select<OrderCost>(orderIds).ToList();
            var orderCostDetailList = fsql.Select<OrderCostDetail>().Where(ocd => orderIds.Contains(ocd.OrderId) && ocd.IsEnabled == true).ToList();
            var afterOrderList = fsql.Select<AfterSaleOrder>().Where(aso => orderIds.Contains(aso.OrderId)).ToList();

            IList<IUpdate<OrderCost>> updateOrderCostList = new List<IUpdate<OrderCost>>();
            IList<IUpdate<OrderCostDetail>> updateOrderCostDetailList = new List<IUpdate<OrderCostDetail>>();

            foreach (var billCorrectionRequest in requestList)
            {
                var order = orderList.FirstOrDefault(o => o.Id == billCorrectionRequest.OrderId);
                if (order == null)
                    continue;
                var orderCost = orderCostList.FirstOrDefault(oc => oc.OrderId == billCorrectionRequest.OrderId);
                if (orderCost == null)
                    continue;
                var currentOrderCostDetailList = orderCostDetailList.Where(ocd => ocd.OrderId == billCorrectionRequest.OrderId).ToList();
                if (currentOrderCostDetailList.Count() == 0 && order.StorageType != Model.Enums.StorageType.SD)
                    continue;
                var currentOrderAfterOrderList = afterOrderList.Where(aso => aso.OrderId == billCorrectionRequest.OrderId).ToList();

                orderCost.DeliveryExpressFreight = billCorrectionRequest.NewDeliveryExpressFreight;
             
                if (order.StorageType != Model.Enums.StorageType.SD)
                {
                    orderCost.CalculationOrderProfitAndCost(order, currentOrderAfterOrderList);
                    var singleDeliveryExpressFreight = billCorrectionRequest.NewDeliveryExpressFreight / currentOrderCostDetailList.Count();
                    foreach (var ocd in currentOrderCostDetailList)
                    {
                        ocd.DeliveryExpressFreight = singleDeliveryExpressFreight;
                        var updateOrderCostDetail = fsql.Update<OrderCostDetail>(ocd.Id)
                                                        .Set(dbOcd => dbOcd.DeliveryExpressFreight, ocd.DeliveryExpressFreight);
                        updateOrderCostDetailList.Add(updateOrderCostDetail);
                    }
                }
                else
                {
                    orderCost.CalculationSDOrderProfitAndCost(order, afterOrderList);
                }

                var updateOrderCost = fsql.Update<OrderCost>(orderCost.OrderId).Set(oc => oc.DeliveryExpressFreight, orderCost.DeliveryExpressFreight)
                                                                               .Set(oc => oc.Profit, orderCost.Profit);
                updateOrderCostList.Add(updateOrderCost);
            }

            fsql.Transaction(() =>
            {
                foreach (var update in updateOrderCostList)
                    update.ExecuteAffrows();
                foreach (var update in updateOrderCostDetailList)
                    update.ExecuteAffrows();
            });
        }
    }
}