DDD实战进阶第一波(十四)：开发一般业务的大健康行业直销系统（订单上下文应用服务用例与接口）

 public class CreateOrderUseCase:BaseAppSrv
    {
        private readonly IOrderRepository iorderrepository;
        private readonly IDealerRepository idealerrepository;
        private readonly IRepository[] irepositories;
        

        public CreateOrderUseCase(IOrderRepository iorderrepository,IDealerRepository idealerrepository,
            params IRepository[] irepositories)
        {
            this.iorderrepository = iorderrepository;
            this.idealerrepository = idealerrepository;
            this.irepositories = irepositories;
        }
        public ResultEntity<bool> CreateOrder(OrderDTO orderdto)
        {
            var orderid = Guid.NewGuid();
            Orders order = new Orders();
            var productskus = new List<ProductSKU>();
            for(int i = 0; i < orderdto.ProductSPUNames.Count; i++)
            {
                var productsku = new ProductSKU();
                productsku.ProductSPUName = orderdto.ProductSPUNames[i];
                productsku.DealerPrice = orderdto.ProductDealerPrices[i];
                productsku.PV = orderdto.ProductPVS[i];
                productsku.Id = orderdto.ProductSKUIds[i];
                productsku.Spec = orderdto.ProductSepcs[i];
                productskus.Add(productsku);
            }
            var contact = new Contact();
            contact.ContactName = orderdto.ContactName;
            contact.ContactTel = orderdto.ContactTel;
            contact.Province = orderdto.Privence;
            contact.City = orderdto.City;
            contact.Zero = orderdto.Zero;
            contact.Street = orderdto.Street;

            var orders = order.CreateOrders(orderid, orderdto.DealerId, productskus, orderdto.Counts,
                contact);

            try
            {
                //using (var tansaction = new TransactionScope())
                //{
                    using (irepositories[1])
                    {
                        idealerrepository.SubParentEleMoney(orderdto.DealerId, order.OrderTotalPrice.TotalPrice);
                        idealerrepository.AddDealerPV(orderdto.DealerId, order.OrderTotalPV.TotalPV);
                        irepositories[1].Commit();

                    }

                    using (irepositories[0])
                    {
                        iorderrepository.CreateOrder(orders);
                        irepositories[0].Commit();
                    }
                return GetResultEntity(true);
                    //tansaction.Complete();
                //}
            }
            catch(EleMoneyNotEnoughException error)
            {
                throw error;
            }
            catch(Exception error)
            {
                throw error;
            }
            
        }
    }

public class OrderEFCoreRepository : IOrderRepository
    {
        private readonly DbContext context;
            
        public OrderEFCoreRepository(DbContext context)
        {
            this.context = context;
        }
        public void CreateOrder<T>(T order) where T:class,IAggregationRoot
        {
            var ordercontext = this.context as OrderEFCoreContext;
            var ordernew = order as Orders;
            try
            {
                ordercontext.Order.Add(ordernew);
            }
            catch(Exception error)
            {
                throw error;
            }
        }
   } 

public void SubParentEleMoney(Guid parentdealerid, decimal subelemoney)
        {
            var dealercontext = this.context as DealerEFCoreContext;
            var parentdealer = dealercontext.Dealer.Single(p => p.Id == parentdealerid);
            parentdealer.TotalEleMoney = parentdealer.TotalEleMoney - subelemoney;
            if (parentdealer.TotalEleMoney < 0)
            {
                throw new EleMoneyNotEnoughException("电子币不够进行此操作!");
            }
            try
            {
                dealercontext.Entry(parentdealer).State = EntityState.Modified;
            }
            catch(Exception error)
            {
                throw error;
            }
        }

        public void AddDealerPV(Guid dealerid, decimal orderpv)
        {
            var dealercontext = this.context as DealerEFCoreContext;
            var dealer = dealercontext.Dealer.Single(p => p.Id == dealerid);
            dealer.TotalPV = dealer.TotalPV +orderpv;
            try
            {
                dealercontext.Entry(dealer).State = EntityState.Modified;
            }
            catch (Exception error)
            {
                throw error;
            }
        }

[HttpPost]
        [Route("CreateOrder")]
        public ResultEntity<bool> CreateOrder([FromBody] OrderDTO orderdto)
        {
            var result = new ResultEntity<bool>();
            var ordercontext = new OrderEFCoreContext();
            var dealercontext = new DealerEFCoreContext();
            var irepository = new EFCoreRepository(ordercontext);
            var irepository1 = new EFCoreRepository(dealercontext);
            var iorderrepository = new OrderEFCoreRepository(ordercontext);
            var idealerrepository = new DealerEFCoreRepository(dealercontext);
            var createorderusecase = new CreateOrderUseCase(iorderrepository, idealerrepository,
                irepository, irepository1);
            try
            {
                result = createorderusecase.CreateOrder(orderdto);
                result.Count = 1;
                result.IsSuccess = true;
                result.Msg = "下单成功!";
            }
            catch (EleMoneyNotEnoughException error)
            {
                result.ErrorCode = 300;
                result.Msg = error.Message;
            }
            catch (Exception error)
            {
                result.ErrorCode = 200;
                result.Msg = error.Message;
            }
            return result;
        }