public async Task Handle(SubmitOrderCommand message, IMessageHandlerContext context)
{
using (var db = new SalesContext())
{
Log.Info("Handle SubmitOrderCommand");
var items = new List <Item>();
var products = db.Products.ToList();
message.Products.ForEach(p => items.Add(new Item
{
Product = products.Single(s => s.Id == p)
}));
var order = new Data.Models.Order
{
CustomerId = message.CustomerId,
DateTimeUtc = DateTime.UtcNow,
Items = items,
State = "New"
};
db.Orders.Add(order);
await db.SaveChangesAsync();
await context.Publish <OrderSubmittedEvent>(e =>
{
e.OrderId = order.Id;
e.CustomerId = message.CustomerId;
e.Products = message.Products;
});
}
}
public void Update(Data.Models.Order order)
{
dbContext.Entry(order.OrderStatus).State = System.Data.Entity.EntityState.Unchanged;
dbContext.Entry(order.Employee).State = System.Data.Entity.EntityState.Unchanged;
dbContext.Entry(order).State = System.Data.Entity.EntityState.Modified;
dbContext.SaveChanges();
}
public void OrderUpdateTest(Data.Models.Order order, Order orderUpdate)
{
var options = new DbContextOptionsBuilder <FakeContext>()
.UseInMemoryDatabase(databaseName: nameof(OrderUpdateTest))
.Options;
orderUpdate.Id = order.Id;
using (var context = new FakeContext(options))
{
context.Orders.Add(order);
context.SaveChanges();
OrderManager manager = new OrderManager(context, _mapper);
manager.Update(orderUpdate);
Assert.Equal(context.Orders.Single(orderData => orderData.Id == order.Id).BeginDate,
orderUpdate.BeginDate);
Assert.Equal(context.Orders.Single(orderData => orderData.Id == order.Id).EndDate,
orderUpdate.EndDate);
Assert.Equal(context.Orders.Single(orderData => orderData.Id == order.Id).CarId,
orderUpdate.CarId);
Assert.Equal(context.Orders.Single(orderData => orderData.Id == order.Id).UserId,
orderUpdate.UserId);
Assert.Equal(context.Orders.Single(orderData => orderData.Id == order.Id).Comment,
orderUpdate.Comment);
}
}
public void Create(Data.Models.Order order)
{
dbContext.Entry(order.Car).State = System.Data.Entity.EntityState.Unchanged;
dbContext.Entry(order.Customer).State = System.Data.Entity.EntityState.Unchanged;
dbContext.Entry(order.OrderStatus).State = System.Data.Entity.EntityState.Unchanged;
dbContext.Entry(order.OrderType).State = System.Data.Entity.EntityState.Unchanged;
dbContext.Entry(order.Employee).State = System.Data.Entity.EntityState.Unchanged;
dbContext.Order.Add(order);
dbContext.SaveChanges();
}
internal static Order ToViewModel(Data.Models.Order order)
{
return(new Order()
{
Id = order.Id,
CustomerId = order.CustomerId,
OrderFulfiled = order.OrderFulfiled,
OrderPlaced = DateTime.Now.ToUniversalTime(),
ProductOrders = order.ProductOrders.Select(x => ProductOrder.ToViewModel(x)).ToList(),
});
}
public async Task <IActionResult> CheckoutAsync(Data.Models.Order order, double Lat, double Lng)
{
if (shoppingCart.IsEmpty)
{
ModelState.AddModelError("CartItems", "Shopping Cart Empty..");
}
var deliveryAreas = restaurant.GetDeliveryAreasByResturantId(shoppingCart.ResturantId);
var list = new List <string>();
foreach (var area in Enum.GetValues <DeliveryAreas>())
{
if (deliveryAreas.HasFlag(area))
{
list.Add(area.ToString());
}
}
order.Address.Area = Regex.Replace(order.Address.Area, @"\s+", "");
if (!list.Contains(order.Address.Area))
{
ModelState.AddModelError("Area", "Area out of coverage");
}
var user = await userManager.Users.Include(U => U.Addresses).SingleOrDefaultAsync(U => U.UserName == User.Identity.Name);
if (ModelState.IsValid)
{
if (order.Address.ID == 0) //Save new address
{
user.Addresses.Add(order.Address);
}
// save for upcoming requests
TempData["Order"] = JsonSerializer.Serialize(order); //order;
TempData["LocalRedirect"] = true;
return(RedirectToAction("Pay"));
}
var orderToPlace = new Data.Models.Order()
{
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email
};
var checkoutVM = new CheckoutViewModel()
{
Order = orderToPlace,
Addresses = user.Addresses,
Lat = Lat,
Lng = Lng,
showMap = 1
};
return(View());
}
public EditOrder(Data.Models.Order order)
{
_order = order;
Id = order.Id;
Car = string.Format("{0} {1}", order.Car.Mark, order.Car.Model);
Customer = string.Format("{0} {1}", order.Customer.Name, order.Customer.Surname);
Employee = string.Format("{0} {1}", order.Employee.Name, order.Employee.Surname);
OrderStatus = order.OrderStatus.Name;
OrderType = order.OrderType.Name;
RepairDescription = order.RepairDescription;
EmployeeId = order.Employee.Id;
OrderStatusId = order.OrderStatus.Id;
OrderStatuses = OtherService.GetOrderStatuses();
}
protected override async Task HandleCore(Command message)
{
var currentUserCart = await this.db.Carts
.Include(c => c.OrderedItems)
.ThenInclude(oi => oi.Product)
.FirstOrDefaultAsync(c => c.User.UserName == message.SenderUserName);
if (currentUserCart.OrderedItems.Any())
{
var order = new Data.Models.Order();
order.DateMade = DateTime.Now;
order.OrderedItems = currentUserCart.OrderedItems;
Mapper.Map(message, order);
this.db.Orders.Add(order);
}
}
public void OrderDeleteTest(Data.Models.Order order)
{
var options = new DbContextOptionsBuilder <FakeContext>()
.UseInMemoryDatabase(databaseName: nameof(OrderDeleteTest))
.Options;
using (var context = new FakeContext(options))
{
context.Orders.Add(order);
context.SaveChanges();
OrderManager manager = new OrderManager(context, _mapper);
manager.Delete(order.Id);
Assert.Null(context.Orders.SingleOrDefault(orderData => orderData.Id == order.Id));
}
}
/// <summary>
/// Map to database model from Service model
/// </summary>
/// <param name="from"></param>
/// <param name="includeDeps"></param>
/// <returns></returns>
public static Data.Models.Order MapBack(Order from, bool includeDeps = true)
{
if (from == null)
{
return(null);
}
var dto = new Data.Models.Order()
{
Id = from.Id,
CustomerId = from.CustomerId,
CreatedDate = from.CreatedDate,
Price = from.Price,
Customer = includeDeps ? CustomerMap.MapBack(from.Customer, false) : null
};
return(dto);
}
public Create GetCreateViewModel(Data.Models.Order order)
{
return(new Create(order)
{
Customers = _customerService.Customers.Select(n => new SelectListItem
{
Value = n.Id.ToString(),
Text = string.Format("{0} {1}", n.Name, n.Surname)
}),
OrderStatuses = OtherService.GetOrderStatuses(),
OrderTypes = OtherService.GetOrderTypes(),
Empolyees = _employeeService.Employees.Select(n => new SelectListItem
{
Value = n.Id.ToString(),
Text = string.Format("{0} {1}", n.Name, n.Surname)
}),
Cars = new List <SelectListItem>()
});
}
public async Task ListsOnlyUnshippedOrders(SliceFixture fixture)
{
// Arrange
// Add some orders
var firstOrder = new Data.Models.Order
{
Name = "Some name",
Line1 = "An address",
City = "City",
Country = "Country",
Zip = "Zip",
State = "State",
Shipped = true
};
var secondOrder = new Data.Models.Order
{
Name = "Some name2",
Line1 = "An address2",
City = "City2",
Country = "Country2",
Zip = "Zip2",
State = "State2",
Shipped = false,
OrderedItems = new List <Data.Models.CartItem>
{
new Data.Models.CartItem()
}
};
await fixture.InsertAsync(firstOrder, secondOrder);
// Act
var query = new Orders.Query();
var ordersReceived = await fixture.SendAsync(query);
// Assert
ordersReceived.Count().ShouldBe(1);
ordersReceived.First().Name.ShouldBe(secondOrder.Name);
ordersReceived.First().Zip.ShouldBe(secondOrder.Zip);
ordersReceived.First().OrderedItems.Count.ShouldBe(secondOrder.OrderedItems.Count);
}
public ServiceResponse <bool> GenerateOpenOrder(Data.Models.Order order)
{
var now = DateTime.UtcNow;
_logger.LogInformation("Generating new order");
foreach (var item in order.OrderItems)
{
item.Product = _productService
.GetProduct(item.Product.Id);
var inventoryId = _inventoryService
.GetByProductId(item.Product.Id).Id;
_inventoryService
.UpdateAvailableQuantity(inventoryId, -item.Quantity);
}
try
{
_db.Orders.Add(order);
_db.SaveChanges();
return(new ServiceResponse <bool>
{
IsSuccess = true,
Data = true,
Message = "Open order created",
Time = now
});
}
catch (Exception e)
{
return(new ServiceResponse <bool>
{
IsSuccess = false,
Data = false,
Message = e.StackTrace,
Time = now
});
}
}
public async Task <IActionResult> Checkout()
{
var user = await userManager.Users.Include(U => U.Addresses).SingleOrDefaultAsync(U => U.UserName == User.Identity.Name);
var orderToPlace = new Data.Models.Order()
{
FirstName = user.FirstName,
LastName = user.LastName,
Email = user.Email
};
var checkoutVM = new CheckoutViewModel()
{
Order = orderToPlace,
Addresses = user.Addresses,
Lat = 30,
Lng = 31,
showMap = 0
};
return(View(checkoutVM));
}
public Create(Data.Models.Order order)
{
_order = order;
}
public OrderDALToOrderBLProfile()
{
var p = new Data.Models.Order();
this.CreateMap <Data.Models.Order, Order>();
}
