public async Task <bool> SaveAsync(OrderModel orderModel)
{
var order = await _orderRepository.GetByIdAsync(orderModel.OrderID);
if (order != null)
{
throw new OrderException($"Order with this id {orderModel.OrderID} already exists.");
}
var company = new Company(orderModel.CompanyID, orderModel.CompanyName);
var newOrder = new Domain.Models.Order(orderModel.OrderID, orderModel.TypeOfOrder, orderModel.SubmittedBy, orderModel.Partner, company);
foreach (var item in orderModel.LineItems)
{
var product = await _productRepository.GetByIdAsync(item.ProductID);
if (product != null)
{
newOrder.AddExistingItem(product);
}
else
{
var newProduct = _productManager.OrderProduct(item.ToLineItemsDTO());
newOrder.AddItem(newProduct);
}
}
return(await _orderRepository.Insert(newOrder));
}
/// <summary>
/// The purpose of this class is to insert new a new order into the database.
/// </summary>
/// <param name="Order">Type Domain.Models.Order. It will contain all data about customer, location, and a list of orderlines.</param>
public int PlaceAnOrderForACustomer(Domain.Models.Order m_order)
{
// Create the Entity item to be put into the database
Entities.OrderEntity order;
order = MapperOrder.MapOrderWithOrderLines(m_order);
// We need to grab the entity objects from the database for the inventory rows for the given location.
// This is so we can update them accordingly.
IEnumerable <Entities.InventoryEntity> dbStocks = _context.Inventories.Where(i => i.LocationId == m_order.LocationPlaced.ID);
// Since we are returned all the rows of inventory we need to iterate through each one to update it
// This is done no matter if there was 1 purchase or many changing the inventory just to be sure
// everything is updated correctly.
foreach (Entities.InventoryEntity i in dbStocks)
{
// We also need to iterate through all the Domain.Models.Stock list for the location
foreach (var orderLine in m_order.Purchase)
{
// An extra measure is taken here just to be sure that only books that exists in the database are being changed.
if (orderLine.BookISBN == i.BookIsbn)
{
i.Quantity -= orderLine.Quantity;
}
}
}
// Add the new order and orderlines to the database
_context.Add(order);
// Save those changes
Save();
return(order.Id);
}
public async Task <Unit> Handle(CreateOrderCommand request, CancellationToken cancellationToken)
{
var entity = new Domain.Models.Order
{
Name = request.Name,
Line1 = request.Line1,
Line2 = request.Line2,
Line3 = request.Line3,
City = request.City,
State = request.State,
Zip = request.Zip,
Country = request.Country,
GiftWrap = request.GiftWrap,
AddedDateTime = dateTime.Now
};
context.Orders.Add(entity);
await context.SaveChangesAsync(cancellationToken);
var lines = request.Lines.Select(s =>
new OrderLine {
GameId = s.Game.Id, OrderId = entity.Id, Quantity = s.Quantity
});
context.OrderLines.AddRange(lines);
await context.SaveChangesAsync(cancellationToken);
return(Unit.Value);
}
public ActionResult PlaceOrder()
{
try
{
if (ModelState.IsValid)
{
_repository.FillBookLibrary();
Domain.Models.ShoppingCart shoppingCart = _cartrepository.GetShoppingCartByCustomerID(Int32.Parse(TempData.Peek("CustomerID").ToString()));
Domain.Models.Order orderAttempt = new Domain.Models.Order();
foreach (var item in shoppingCart.CartItems)
{
orderAttempt.AddNewOrderLine($"{item.Book.ISBN}, {item.Quantity}");
}
orderAttempt.CustomerPlaced = _repository.GetCustomers().Where(c => c.ID == Int32.Parse(TempData.Peek("CustomerID").ToString())).First();
orderAttempt.LocationPlaced = orderAttempt.CustomerPlaced.MyStoreLocation;
orderAttempt.LocationPlaced.AttemptOrderAtLocation(orderAttempt);
int newOrderNumber = _repository.PlaceAnOrderForACustomer(orderAttempt);
_cartrepository.EmptyCart(orderAttempt.CustomerPlaced);
TempData["TotalCartItems"] = orderAttempt.CustomerPlaced.GetCartItemCount();
return(RedirectToAction("Details", "Order", new { id = newOrderNumber, justPlaced = true }));
}
return(View(nameof(Index)));
}
catch (Exception)
{
return(View(nameof(Index)));
}
}
public async Task <IActionResult> OnPostAsync(
string paymentId,
[FromServices] CreateOrder createOrder,
[FromServices] GetCart getCart,
[FromServices] PaymentIntentService paymentIntentService,
[FromServices] ILogger <Payment> logger)
{
var userId = User.GetUserId();
var cartId = await getCart.Id(userId);
if (cartId == 0)
{
logger.LogWarning($"Cart not found for {userId} with payment id {paymentId}");
return(RedirectToPage("/Checkout/Error"));
}
var payment = await paymentIntentService.CaptureAsync(paymentId);
if (payment == null)
{
logger.LogWarning($"Payment Intent not found {paymentId}");
return(RedirectToPage("/Checkout/Error"));
}
var order = new Domain.Models.Order
{
StripeReference = paymentId,
CartId = cartId,
};
await createOrder.Do(order);
return(RedirectToPage("/Checkout/Success", new { orderId = order.Id }));
}
public static Entities.OrderEntity Map(Domain.Models.Order order)
{
return(new Entities.OrderEntity
{
Id = order.OrderNumber,
CustomerId = order.CustomerPlaced.ID,
LocationId = order.LocationPlaced.ID
});
}
/// <summary>
/// Turn a model object into an entity order with their orderlines
/// </summary>
/// <param name="order"></param>
/// <returns></returns>
public static Entities.OrderEntity MapOrderWithOrderLines(Domain.Models.Order order)
{
return(new Entities.OrderEntity
{
Id = order.OrderNumber,
CustomerId = order.CustomerPlaced.ID,
LocationId = order.LocationPlaced.ID,
Orderlines = order.Purchase.Select(MapperOrderLine.Map).ToList()
});
}
/// <summary>
/// Async Method that sends order object message to the bus
/// </summary>
/// <param name="order">Order object</param>
public async Task SendMessageAsync(Domain.Models.Order order)
{
var uri = new Uri("rabbitmq://localhost/order_queue");
var endpoint = await _bus.GetSendEndpoint(uri);
await endpoint.Send(order);
_logger.LogDebug("Message sent");
}
public async Task AddAsync(Domain.Models.Order order)
{
if (order.Status != Common.OrderStatus.Active)
{
var query = Builders <Domain.Models.Order> .Filter.Where(o => o.Id == order.Id);
await Collection.DeleteOneAsync(query);
}
await Collection.InsertOneAsync(order);
}
public static OrderViewModel ToOrderViewModel(this Domain.Models.Order order)
{
return(new OrderViewModel
{
Id = order.Id,
Delivered = order.Delivered,
PaymentMethod = order.PaymentMethod,
PizzaStore = order.PizzaStore,
UserId = order.User.Id
});
}
public Domain.Models.Order Map(Entities.Order Order)
{
Domain.Models.Order mapOrder = new Domain.Models.Order();
mapOrder.ID = Order.ID;
mapOrder.Store = Map(Order.Store);
mapOrder.Customer = Map(Order.Customer);
mapOrder.TotalPrice = Order.TotalPrice;
mapOrder.TimePlaced = Order.TimePlaced;
Order.Pizzas.ToList().ForEach(p => mapOrder.Pizzas.Add(Map(p)));
return(mapOrder);
}
public async Task <IActionResult> OnPostAsync(
string paymentId,
[FromServices] CreateOrder createOrder,
[FromServices] GetCart getCart)
{
var order = new Domain.Models.Order
{
StripeReference = paymentId,
CartId = await getCart.Id(User.GetUserId()),
};
await createOrder.Do(order);
return(RedirectToPage("/Checkout/Success", new { orderId = order.Id }));
}
public async Task <IActionResult> CreateOrderAsync([FromBody] Domain.Models.Order order)
{
try
{
await _orderService.SendMessageAsync(order);
return(Ok());
}
catch (Exception e)
{
_logger.LogError(e.Message);
return(BadRequest(e.Message));
}
}
public static Web.Response.ResourceViewModels.Order MapDomainToOrderResponse(Domain.Models.Order order)
{
return(new Web.Response.ResourceViewModels.Order
{
CustomerName = order.CustomerName,
ServerName = order.ServerName,
OrderState = order.OrderState,
Items = order.Items.Select(x => new Web.Response.ResourceViewModels.OrderItem
{
Name = x.Name,
Price = x.Price,
Quantity = x.Quantity
}).ToList()
});
}
public static OrderDetailsViewModel ToOrderDetailsViewModel(this Domain.Models.Order order)
{
double price = 0;
foreach (var pizzaOrder in order.PizzaOrders)
{
price += pizzaOrder.Price;
}
return(new OrderDetailsViewModel
{
Id = order.Id,
Delivered = order.Delivered,
PaymentMethod = order.PaymentMethod,
PizzaStore = order.PizzaStore,
UserFullName = $"{order.User.FirstName} {order.User.LastName}",
PizzaNames = order.PizzaOrders.Select(x => x.Pizza.Name).ToList(),
Price = price
});
}
public async Task SendOrderConfirmationEmailAsync(Domain.Models.Order order)
{
_mail.To.Add(new MailboxAddress("Reciever", "*****@*****.**"));
_mail.Subject = order.ProductName;
try
{
using var client = new MailKit.Net.Smtp.SmtpClient();
await client.ConnectAsync("smtp.gmail.com", 587, false);
await client.AuthenticateAsync(_connectionDataOptions.Value.UserName, _connectionDataOptions.Value.Password);
await client.SendAsync(_mail);
await client.DisconnectAsync(true);
}
catch (SmtpException exception)
{
System.Console.WriteLine(exception.Message);
}
}
public async Task <IActionResult> OnPostAsync(
string paymentId,
[FromServices] CreateOrder createOrder,
[FromServices] GetCart getCart,
[FromServices] PaymentIntentService paymentIntentService)
{
var payment = await paymentIntentService.GetAsync(paymentId);
if (payment == null)
{
//todo do some kinda notification that this went wrong.
return(RedirectToPage());
}
var order = new Domain.Models.Order
{
StripeReference = paymentId,
CartId = await getCart.Id(User.GetUserId()),
};
await createOrder.Do(order);
return(RedirectToPage("/Checkout/Success", new { orderId = order.Id }));
}
public async Task <IActionResult> Index(
[FromServices] IOptionsMonitor <StripeSettings> optionsMonitor,
[FromServices] CreateOrder createOrder,
[FromServices] GetCart getCart)
{
StripeConfiguration.ApiKey = optionsMonitor.CurrentValue.SecretKey;
var json = await new StreamReader(HttpContext.Request.Body).ReadToEndAsync();
try
{
var stripeEvent = EventUtility.ConstructEvent(json,
Request.Headers["Stripe-Signature"],
optionsMonitor.CurrentValue.SigningSecret);
_logger.LogInformation("received stripe event {0} {1}", Environment.NewLine, json);
if (stripeEvent.Type == Events.PaymentIntentCreated)
{
var paymentMethod = stripeEvent.Data.Object as PaymentIntent;
}
else if (stripeEvent.Type == Events.ChargeSucceeded)
{
var paymentMethod = stripeEvent.Data.Object as Charge;
}
else if (stripeEvent.Type == Events.PaymentMethodAttached)
{
var paymentMethod = stripeEvent.Data.Object as PaymentMethod;
}
else if (stripeEvent.Type == Events.PaymentIntentSucceeded)
{
var paymentIntent = stripeEvent.Data.Object as PaymentIntent;
}
else if (stripeEvent.Type == Events.CustomerCreated)
{
var paymentMethod = stripeEvent.Data.Object as Customer;
}
else if (stripeEvent.Type == Events.CheckoutSessionCompleted)
{
var checkoutSession = stripeEvent.Data.Object as Session;
var order = new Domain.Models.Order
{
StripeReference = checkoutSession.Id,
CartId = await getCart.Id(checkoutSession.Metadata["user_id"]),
};
await createOrder.Do(order);
_logger.LogInformation("created order {0},{1}: {2}", order.Id, Environment.NewLine,
JsonConvert.SerializeObject(order));
}
else
{
return(BadRequest());
}
return(Ok());
}
catch (StripeException e)
{
return(BadRequest(e.Message));
}
}
/// <summary>
/// 根据销售单状态反向写入订单状态，由同一订单下所有发货单状态来决策出订单状态
/// 订单如果发货了，则需要同步发货状态及发货包裹,插入发货日志
/// 目前实现有很大的问题 wxh备注 2014-04-20 0:17:43
/// </summary>
/// <param name="opcSale"></param>
private void SetOrderStatus(Domain.Models.Order order)
{
const int PrepareShip = 7;
const int Shipping = 8;
using (var db = new YintaiHZhouContext())
{
using (var ts = new TransactionScope())
{
var p = db.Orders.FirstOrDefault(t => t.OrderNo == order.OrderNo);
var saleOrders = db.OPC_Sale.Where(sa => sa.OrderNo == p.OrderNo).ToList();
var status = CheckStatus(saleOrders);
if (status == order.Status || status == NoStatus)
{
return;
}
p.UpdateDate = DateTime.Now;
p.Status = status;
p.UpdateUser = SystemDefine.SystemUser;
if (status == (int)EnumOrderStatus.PreparePack)
{
db.OrderLogs.Add(new OrderLog()
{
CreateDate = DateTime.Now,
CreateUser = 0,
CustomerId = order.CustomerId,
Operation = order.Memo ?? "准备发货",
OrderNo = order.OrderNo,
Type = PrepareShip,
});
}
if (status == (int)EnumOrderStatus.Shipped)
{
db.OrderLogs.Add(new OrderLog()
{
CreateDate = DateTime.Now,
CreateUser = 0,
CustomerId = order.CustomerId,
Operation = "已发货",
OrderNo = order.OrderNo,
Type = Shipping,
});
foreach (int shippingId in saleOrders.Select(x => x.ShippingSaleId).Distinct().Where(x => x.HasValue))
{
var shipping = db.OPC_ShippingSale.FirstOrDefault(x => x.Id == shippingId);
var shippingItems =
db.OPC_Sale.Where(
x => x.ShippingSaleId.HasValue && x.ShippingSaleId.Value == shipping.Id)
.Join(db.OPC_SaleDetail, s => s.SaleOrderNo, d => d.SaleOrderNo, (s, d) => d)
.Join(db.OrderItems, d => d.OrderItemID, x => x.Id,
(detail, item) => new { detail, item });
if (shipping == null)
{
continue;
}
var outboundNo = CreateOutBoundNo(shipping.StoreId.HasValue ? shipping.StoreId.Value : 0);
db.Outbounds.Add(new Outbound()
{
OutboundNo = outboundNo,
SourceNo = shipping.OrderNo,
SourceType = 1,
ShippingContactPerson = shipping.ShippingContactPerson,
CreateDate = DateTime.Now,
CreateUser = 0,
Status = 1,
ShippingVia = shipping.ShipViaId,
ShippingNo = shipping.ShippingCode,
ShippingAddress = shipping.ShippingAddress,
UpdateDate = DateTime.Now,
UpdateUser = 0
});
foreach (var di in shippingItems)
{
db.OutboundItems.Add(new OutboundItem()
{
CreateDate = DateTime.Now,
ColorId = di.item.ColorValueId,
ItemPrice = di.item.ItemPrice,
UnitPrice = di.item.UnitPrice.Value,
ExtendPrice = di.item.ExtendPrice,
OutboundNo = outboundNo,
ProductId = di.item.ProductId,
Quantity = di.detail.SaleCount,
SizeId = di.item.SizeValueId,
UpdateDate = DateTime.Now
});
}
}
}
db.SaveChanges();
ts.Complete();
Log.InfoFormat("完成订单状态更新,orderNo:{0},status:{1}", p.OrderNo, status);
}
}
}
private void Split(Domain.Models.Order order)
{
using (var db = new YintaiHZhouContext())
{
using (var ts = new TransactionScope())
{
var items =
db.OrderItems.Where(i => i.OrderNo == order.OrderNo)
.Join(db.Products, i => i.ProductId, p => p.Id, (i, p) => new { product = p, item = i })
.Join(db.IMS_Associate.Where(a => a.Status == 1), x => x.product.CreatedUser, a => a.UserId,
(x, a) => new { x.item, sectionid = a.SectionId }).GroupBy(x => x.sectionid);
int idx = 1;
foreach (var item in items)
{
var saleOrderNo = string.Format("{0}-{1}", idx.ToString("D").PadLeft(3, '0'), order.OrderNo);
var sectionId = item.Key;
var section = db.Sections.FirstOrDefault(s => s.Id == sectionId);
//var sectionCode =
// db.OPC_ChannelMap.FirstOrDefault(
// x => x.MapType == (int)ChannelMapType.SectionId && x.InnerValue == sectionId);
decimal saleAmount = 0;
int salesCount = 0;
foreach (var p in item)
{
saleAmount += p.item.ItemPrice * p.item.Quantity;
salesCount += p.item.Quantity;
db.OPC_SaleDetail.Add(new OPC_SaleDetail()
{
SaleOrderNo = saleOrderNo,
CreatedDate = DateTime.Now,
CreatedUser = -10000,
OrderItemID = p.item.Id,
Price = p.item.ItemPrice,
ProdSaleCode = p.item.StoreSalesCode,
Remark = "自拍商品订单",
SaleCount = p.item.Quantity,
RemarkDate = DateTime.Now,
SectionCode = section == null ? string.Empty : section.SectionCode,
Status = 0,
StockId = -1,
UpdatedDate = DateTime.Now,
UpdatedUser = -10000,
});
}
db.OPC_Sale.Add(new OPC_Sale()
{
OrderNo = order.OrderNo,
SaleOrderNo = saleOrderNo,
SalesType = 0,
Status = 0,
SellDate = order.CreateDate,
SalesAmount = saleAmount,
SalesCount = salesCount,
SectionId = item.Key,
Remark = "自拍商品订单",
RemarkDate = DateTime.Now,
CreatedUser = -10000,
CreatedDate = DateTime.Now,
UpdatedUser = -10000,
UpdatedDate = DateTime.Now,
});
var splitLog = new OPC_OrderSplitLog
{
OrderNo = order.OrderNo,
Reason = "拆单成功",
Status = 1,
CreateDate = DateTime.Now
};
db.OPC_OrderSplitLog.Add(splitLog);
db.SaveChanges();
idx += 1;
}
ts.Complete();
Log.ErrorFormat("自拍商品拆单成功 OrderNo = {0}", order.OrderNo);
}
}
}
public void AddOrder(Domain.Models.Order order, int storeID, int userID)
{
var newOrder = new Order();
newOrder.DateOrdered = order.DateOrdered.ToString();
newOrder.UserId = userID;
newOrder.StoreId = storeID;
newOrder.Placed = order.Placed;
newOrder.Completed = order.Completed;
db.Order.Add(newOrder);
db.SaveChanges();
var newOrderJunction = new OrderJunction();
newOrderJunction.Order = newOrder;
newOrderJunction.StoreId = storeID;
foreach (var pizza in order.Pizzas)
{
var newPizza = new Pizza();
newPizza.Crust = new Crust()
{
Name = pizza.Crust.Name
};
newPizza.Size = new Size()
{
Name = pizza.Size.pSize
};
newPizza.Name = pizza.Name;
db.Pizza.Add(newPizza);
db.SaveChanges();
foreach (var top in pizza.Toppings)
{
foreach (var dbtop in db.Topping.ToList())
{
if (top.Name.Equals(dbtop.Name))
{
PizzaTopping ptop = new PizzaTopping();
ptop.PizzaId = newPizza.PizzaId;
ptop.ToppingId = dbtop.ToppingId;
db.PizzaTopping.Add(ptop);
db.SaveChanges();
}
}
// PizzaTopping ptop = new PizzaTopping();
// ptop.Pizza = newPizza;
// ptop.Topping = new Topping() {Name = top.Name};
// db.PizzaTopping.Add(ptop);
}
var pj = new PizzaJunction();
pj.Order = newOrder;
pj.Pizza = newPizza;
db.PizzaJunction.Add(pj);
db.SaveChanges();
}
db.SaveChanges();
}
public async Task <bool> Insert(Domain.Models.Order order)
{
_context.Orders.Add(order);
return(await _context.SaveChangesAsync() > 0);
}
