/// <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);
}
