/// <summary> /// 消耗定单 /// </summary> static void DisposeOrder(object o) { OrderIdentity order = o as OrderIdentity; List <OrderIdentity> all = Cache.Get <List <OrderIdentity> >(LIMIT_QUENE_TAG); OrderIdentity oi = all.FirstOrDefault(t => t.Id == order.Id); if (oi.State == OrderState.Untreated) { try { //数据库创建订单 lock (_databaselocker)//锁数据库操作 { var orders = iorder.CreateOrder(order.Order); var orderIds = orders.Select(item => item.Id).ToArray(); oi.State = OrderState.Processed; oi.Message = "下单成功!"; oi.OrderIds = orderIds; UpdateOrder(oi); } } catch (Exception e) //数据库创建订单失败 { lock (_locker[order.Order.SkuIds.ElementAt(0)]) //锁库存 { int sellcount = int.Parse(Cache.Get(LIMIT_COUNT_TAG + order.Order.SkuIds.ElementAt(0)).ToString()); sellcount = sellcount - order.Order.Counts.ElementAt(0); Cache.Insert(LIMIT_COUNT_TAG + order.Order.SkuIds.ElementAt(0), sellcount); oi.State = OrderState.Fail; oi.Message = "下单失败:" + e.Message; UpdateOrder(oi); } } } }
public void CanConstructValidOrder() { // Arrange var id = new OrderIdentity(Guid.NewGuid()); var customerId = new CustomerIdentity(Guid.NewGuid()); var orderDate = new DateTime(2020, 4, 3); var status = OrderStatus.Draft; var orderItems = new List <IReadonlyOrderItem> { new OrderItem(new OrderItemIdentity(Guid.NewGuid()), new ProductIdentity(Guid.NewGuid()), 40.56m, 20, OrderItemStatus.Pending), new OrderItem(new OrderItemIdentity(Guid.NewGuid()), new ProductIdentity(Guid.NewGuid()), 57.12m, 30, OrderItemStatus.Allocated), }; // Act var order = new Order(id, customerId, orderDate, status, orderItems); // Assert order.Id.Should().Be(id); order.CustomerId.Should().Be(customerId); order.OrderDate.Should().Be(orderDate); order.Status.Should().Be(status); order.OrderItems.Should().BeEquivalentTo(orderItems); }
public async Task RemoveAsync(OrderIdentity orderId) { var orderRecord = GetOrderRecord(orderId); Context.Remove(orderRecord); await Context.SaveChangesAsync(); }
public Task <bool> ExistsAsync(OrderIdentity orderId) { var orderRecordId = orderId.Value; return(Context.Orders.AsNoTracking() .AnyAsync(e => e.Id == orderRecordId)); }
/// <summary> /// 获得订单状态 /// </summary> /// <param name="id">缓存订单标识</param> /// <param name="message">返回缓存订单相关消息</param> /// <param name="orderids">处理成功时返回实际订单标识</param> /// <returns>缓存订单状态</returns> public OrderState GetOrderState(string id, out string message, out long[] orderids) { message = ""; orderids = null; List <OrderIdentity> all = Cache.Get <List <OrderIdentity> >(LIMIT_QUENE_TAG); OrderIdentity o = all.FirstOrDefault(t => t.Id == id); if (o != null) { if (o.State == OrderState.Processed) { orderids = o.OrderIds; message = o.Message; RemoveOrder(o.Id); } else if (o.State == OrderState.Fail) { message = o.Message; RemoveOrder(o.Id); } else if (o.State == OrderState.Untreated) { message = o.Message; } return(o.State); } else { message = "订单失踪,服务器异常"; return(OrderState.Exception); } }
private OrderIdNameReadModel GetIdNameResult(OrderRecord record) { var id = new OrderIdentity(record.Id); var name = record.Id.ToString(); return(new OrderIdNameReadModel(id, name)); }
private OrderRecord GetOrderRecord(OrderIdentity orderId) { return(new OrderRecord { Id = orderId, }); }
private OrderRecord GetOrderRecord(OrderIdentity orderId) { var id = orderId.Value; return(new OrderRecord { Id = id, }); }
private Order GetOrder(OrderRecord record) { var id = new OrderIdentity(record.Id); var customerId = new CustomerIdentity(record.CustomerId); var status = record.OrderStatusId; var orderDetails = record.OrderItems.Select(GetOrderItem).ToList().AsReadOnly(); return(new Order(id, customerId, DateTime.Now, status, orderDetails)); }
private OrderHeaderReadModel GetOrderHeaderReadModel(OrderRecord record) { var orderId = new OrderIdentity(record.Id); var customerId = new CustomerIdentity(record.CustomerId); var orderDate = record.OrderDate; var status = (OrderStatus)record.OrderStatusId; var totalPrice = record.OrderItems.Sum(e => e.UnitPrice * e.Quantity); return(new OrderHeaderReadModel(orderId, customerId, orderDate, status, totalPrice)); }
private Order GetOrder(OrderRecord record) { var id = new OrderIdentity(record.Id); var customerId = new CustomerIdentity(record.CustomerId); OrderStatus status = (OrderStatus)record.OrderStatusId; // TODO: VC var orderDetails = record.OrderItems.Select(GetOrderItem).ToList().AsReadOnly(); // TODO: VC: OrderDetails is empty list, need to Include it in EF so that it loads... return(new Order(id, customerId, DateTime.Now, status, orderDetails)); }
public async Task <Order> FindAsync(OrderIdentity orderId) { var orderRecord = await Context.Orders.AsNoTracking() .Include(e => e.OrderItems) .FirstOrDefaultAsync(e => e.Id == orderId); if (orderRecord == null) { return(null); } return(GetOrder(orderRecord)); }
public async Task <Order> FindAsync(OrderIdentity orderId) { var orderRecord = await Context.Orders .Find(e => e.Id == orderId) .FirstOrDefaultAsync(); if (orderRecord == null) { return(null); } return(GetOrder(orderRecord)); }
/// <summary> /// 线程处理程序 消耗订单 /// </summary> static void ThreadMain() { Thread.Sleep(TREADSLEEP); List <OrderIdentity> all = null; if (!Cache.Exists(LIMIT_QUENE_TAG)) { all = new List <OrderIdentity>(); Cache.Insert <List <OrderIdentity> >(LIMIT_QUENE_TAG, all); } else { all = Cache.Get <List <OrderIdentity> >(LIMIT_QUENE_TAG); } for (int k = 0; k < all.Count; k++) { OrderIdentity order = all[k]; #region 处理未处理订单 if (all[k].State == OrderState.Untreated) { try { //数据库创建订单 lock (_databaselocker)//锁数据库操作 { var orders = iorder.CreateOrder(order.Order); var orderIds = orders.Select(item => item.Id).ToArray(); order.State = OrderState.Processed; order.Message = "下单成功!"; order.OrderIds = orderIds; UpdateOrder(order); } } catch (Exception e) //数据库创建订单失败 { lock (_locker[order.Order.SkuIds.ElementAt(0)]) //锁库存 { int sellcount = int.Parse(Cache.Get(LIMIT_COUNT_TAG + order.Order.SkuIds.ElementAt(0)).ToString()); sellcount = sellcount - order.Order.Counts.ElementAt(0); Cache.Insert(LIMIT_COUNT_TAG + order.Order.SkuIds.ElementAt(0), sellcount); order.State = OrderState.Fail; order.Message = "下单失败,异常原因:" + e.Message; UpdateOrder(order); } } } #endregion } }
public async Task <FindOrderResponse> HandleAsync(FindOrderRequest request) { var orderId = new OrderIdentity(request.Id); var order = await _orderReadRepository.FindAsync(orderId); if (order == null) { throw new NotFoundRequestException(); } var response = _mapper.Map <Order, FindOrderResponse>(order); return(response); }
static void AddOrder(OrderIdentity order) { lock (_quenelocker) { List <OrderIdentity> all = Cache.Get <List <OrderIdentity> >(LIMIT_QUENE_TAG); if (all == null) { all = new List <OrderIdentity>(); } if (order != null) { all.Add(order); Cache.Insert <List <OrderIdentity> >(LIMIT_QUENE_TAG, all); } } }
private Order CreateDraftOrder() { var id = new OrderIdentity(Guid.NewGuid()); var customerId = new CustomerIdentity(Guid.NewGuid()); var orderDate = new DateTime(2020, 4, 3); var status = OrderStatus.Draft; var orderItems = new List <IReadonlyOrderItem> { new OrderItem(new OrderItemIdentity(Guid.NewGuid()), new ProductIdentity(Guid.NewGuid()), 40.56m, 20, OrderItemStatus.Pending), new OrderItem(new OrderItemIdentity(Guid.NewGuid()), new ProductIdentity(Guid.NewGuid()), 57.12m, 30, OrderItemStatus.Allocated), }; return(new Order(id, customerId, orderDate, status, orderItems)); }
public async Task <SubmitOrderCommandResponse> HandleAsync(SubmitOrderCommand request) { var orderId = new OrderIdentity(request.Id); var order = await _orderRepository.FindAsync(orderId); if (order == null) { throw new ExistenceException(); } order.Submit(); await _orderRepository.UpdateAsync(order); return(_mapper.Map <Order, SubmitOrderCommandResponse>(order)); }
static void RemoveOrder(string id) { lock (_quenelocker) { List <OrderIdentity> all = Cache.Get <List <OrderIdentity> >(LIMIT_QUENE_TAG); if (all == null) { return; } OrderIdentity order = all.FirstOrDefault(t => t.Id == id); if (order != null) { all.Remove(order); Cache.Insert <List <OrderIdentity> >(LIMIT_QUENE_TAG, all); } } }
/// <summary> /// 下单 /// </summary> /// <param name="id">返回缓存预约单标识</param> /// <param name="order">预约单数据实体</param> /// <returns>下单结果</returns> public static Himall.Web.App_Code.Common.SubmitOrderResult SubmitOrder(OrderCreateModel order, out string id, string payPwd = "") { id = ""; if (((order.Capital > 0) && !string.IsNullOrEmpty(payPwd)) && !MemberApplication.VerificationPayPwd(order.CurrentUser.Id, payPwd)) { return(SubmitOrderResult.ErrorPassword); } if (order == null) { return(Common.SubmitOrderResult.NoData); } else if (order.SkuIds == null || order.SkuIds.Count() == 0 || string.IsNullOrEmpty(order.SkuIds.ElementAt(0))) { return(SubmitOrderResult.NoSkuId); } if (!_locker.Keys.Contains(order.SkuIds.ElementAt(0))) { return(SubmitOrderResult.NoLimit); } string skuid = order.SkuIds.ElementAt(0); lock (_locker[skuid])//锁库存 { int sellcount = int.Parse(Cache.Get(LIMIT_COUNT_TAG + skuid).ToString()); int total = int.Parse(Cache.Get(LIMIT_TOTAL_TAG + skuid).ToString()); int buy = order.Counts.ElementAt(0); if (sellcount + buy > total)//判断是否超卖 { return(SubmitOrderResult.SoldOut); } sellcount = sellcount + buy; Cache.Insert(LIMIT_COUNT_TAG + skuid, sellcount); //更新库存 OrderIdentity myorder = new OrderIdentity(); //给预约单加标识 myorder.Id = Guid.NewGuid().ToString(); myorder.Order = order; myorder.State = OrderState.Untreated; myorder.Message = "预约单正在处理"; id = myorder.Id; AddOrder(myorder); Cache.Send(LIMIT_LIST_TAG + skuid, myorder);//发消息后台处理 return(SubmitOrderResult.Success); } }
public async Task <CancelOrderResponse> HandleAsync(CancelOrderRequest request) { var orderId = new OrderIdentity(request.Id); var order = await _orderRepository.FindAsync(orderId); if (order == null) { throw new NotFoundRequestException(); } order.Cancel(); await _orderRepository.UpdateAsync(order); await _unitOfWork.SaveChangesAsync(); return(_mapper.Map <Order, CancelOrderResponse>(order)); }
static void UpdateOrder(OrderIdentity order) { lock (_quenelocker) { List <OrderIdentity> all = Cache.Get <List <OrderIdentity> >(LIMIT_QUENE_TAG); if (all == null) { return; } if (order != null) { for (int i = 0; i < all.Count; i++) { if (all[i].Id == order.Id) { all[i] = order; } } Cache.Insert <List <OrderIdentity> >(LIMIT_QUENE_TAG, all); } } }
/// <summary> /// 下单 /// </summary> /// <param name="id">返回缓存订单标识</param> /// <param name="order">订单数据实体</param> /// <returns>下单结果</returns> public SubmitOrderResult SubmitOrder(OrderCreateModel order, out string id) { id = ""; if (order == null) { return(SubmitOrderResult.NoData); } else if (order.SkuIds == null || order.SkuIds.Count() == 0 || string.IsNullOrEmpty(order.SkuIds.ElementAt(0))) { return(SubmitOrderResult.NoSkuId); } if (!_locker.Keys.Contains(order.SkuIds.ElementAt(0))) { return(SubmitOrderResult.NoLimit); } string skuid = order.SkuIds.ElementAt(0); lock (_locker[skuid])//锁库存 { int sellcount = int.Parse(Cache.Get(LIMIT_COUNT_TAG + skuid).ToString()); int total = int.Parse(Cache.Get(LIMIT_TOTAL_TAG + skuid).ToString()); int buy = order.Counts.ElementAt(0); if (sellcount + buy > total)//判断是否超卖 { return(SubmitOrderResult.SoldOut); } sellcount = sellcount + buy; Cache.Insert(LIMIT_COUNT_TAG + skuid, sellcount); //更新库存 OrderIdentity myorder = new OrderIdentity(); //给订单加标识 myorder.Id = Guid.NewGuid().ToString(); myorder.Order = order; myorder.State = OrderState.Untreated; myorder.Message = "订单正在处理"; id = myorder.Id; AddOrder(myorder); Cache.Send(LIMIT_LIST_TAG + skuid, myorder);//发消息后台处理 return(SubmitOrderResult.Success); } }
public Task <bool> ExistsAsync(OrderIdentity orderId) { return(Context.Orders.AsNoTracking() .AnyAsync(e => e.Id == orderId)); }
public Task RemoveAsync(OrderIdentity orderId) { return(Context.Orders .DeleteOneAsync(e => e.Id == orderId)); }
public Task <bool> ExistsAsync(OrderIdentity orderId) { return(Context.Orders .Find(e => e.Id == orderId) .AnyAsync()); }
public void Remove(OrderIdentity orderId) { var orderRecord = GetOrderRecord(orderId); Context.Remove(orderRecord); }