public async Task UpsertAsync(ManageOrder manageOrder)
{
void insertOrder(Order order)
{
order.CreatedDate = DateTime.UtcNow;
order.ModifiedDate = DateTime.UtcNow;
foreach (var item in order.OrderProducts)
{
_orderContext.Entry(item).State = EntityState.Added;
}
_orderContext.Entry(order).State = EntityState.Added;
}
void updateOrder(Order order)
{
order.ModifiedDate = DateTime.UtcNow;
_orderContext.Entry(order).State = EntityState.Modified;
}
foreach (var order in manageOrder.Orders)
{
if (order.State == TrackingState.Added)
{
insertOrder(order);
}
else if (order.State == TrackingState.Modified)
{
updateOrder(order);
}
}
await _orderContext.SaveChangesAsync();
}
public void ShouldNotAllowOrderToAddWhenThereIsOverlapDateTime()
{
var gasStation = _orderData.GasStations.First();
var inputOrder = new InputOrder
{
CarrierId = Guid.NewGuid(),
Comments = "Manual Order",
OrderType = SharedKernel.Enums.OrderType.Manual,
GasStationId = gasStation.Id,
FromTime = new DateTime(2020, 11, 8, 7, 0, 0),
ToTime = new DateTime(2020, 11, 8, 10, 0, 0),
LineItems = gasStation.Tanks.Select(
x => new InputOrderProduct
{
TankId = x.Id,
Quantity = x.Measurement.Quantity
})
};
Order?entity = Order.Create(inputOrder, gasStation) !.Entity;
var manageOrder = new ManageOrder(_orderData.Orders);
Assert.True(manageOrder.Add(entity !).IsConflicting);
Assert.True(manageOrder.Orders.Count(x => x.GasStationId == entity !.GasStationId) == 3);
}
public ActionResult Edit([Bind(Include = "OrderId,OrderName,OrderCity,OrderCountry,OrderAddress,OrderDescription,Status,Amount,UserId")] ManageOrder manageOrder)
{
try
{
if (Convert.ToInt32(Session["RoleId"]) == 1)
{
if (ModelState.IsValid)
{
db.Entry(manageOrder).State = EntityState.Modified;
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.UserId = new SelectList(db.Users, "UserId", "Username", manageOrder.UserId);
return(View(manageOrder));
}
else
{
return(RedirectToAction("Login", "Users"));
}
}
catch (Exception ex)
{
throw ex;
}
}
// GET: ManageOrders/Edit/5
public ActionResult Edit(int?id)
{
try
{
if (Convert.ToInt32(Session["RoleId"]) == 1)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
ManageOrder manageOrder = db.ManageOrders.Find(id);
if (manageOrder == null)
{
return(HttpNotFound());
}
ViewBag.UserId = new SelectList(db.Users, "UserId", "Username", manageOrder.UserId);
return(View(manageOrder));
}
else
{
return(RedirectToAction("Login", "Users"));
}
}
catch (Exception ex)
{
throw ex;
}
}
public async Task <ManageOrder> GetOrdersByGasStationIdAsync(Guid gasStationId)
{
var orders = await _orderContext.Orders
.Where(o => o.GasStationId == gasStationId).ToListAsync();
var manageOrder = new ManageOrder();
foreach (var order in orders)
{
manageOrder.Add(order);
}
return(manageOrder);
}
public async Task ShouldReturnOrderByGasStationIdAndDeliveryDate()
{
var order = _orderData.GetOrders().First();
var manageOrder = new ManageOrder();
manageOrder.Add(order);
await _manageOrderRepository.UpsertAsync(manageOrder);
var res = await _manageOrderRepository.GetOrderByGasStationIdDeliveryDateAsync(order.GasStationId,
order.DispatchDate);
Assert.NotNull(res);
Assert.True(res.Id > 0);
}
public async Task ShouldCreateOrderWhenThereIsNoOverlappingDatesWithPreviousOrders()
{
var order = _orderData.GetOrders().First();
order.State = TrackingState.Added;
var manageOrder = new ManageOrder();
manageOrder.Add(order);
await _manageOrderRepository.UpsertAsync(manageOrder);
var result = await _manageOrderRepository.GetOrdersByGasStationIdAsync(order.GasStationId);
Assert.NotEmpty(result.Orders);
Assert.Equal(order.GasStationId, result.Orders.First().GasStationId);
}
public ActionResult Create([Bind(Include = "OrderId,OrderName,OrderCity,OrderCountry,OrderAddress,OrderDescription,Status,Amount,UserId")] ManageOrder manageOrder)
{
try
{
if (ModelState.IsValid)
{
db.ManageOrders.Add(manageOrder);
db.SaveChanges();
return(RedirectToAction("Index"));
}
ViewBag.UserId = new SelectList(db.Users, "UserId", "Username", manageOrder.UserId);
return(View(manageOrder));
}
catch (Exception ex)
{
throw ex;
}
}
public MockRepoHelper(IOrderDataFixture orderData)
{
MockGasStationScheduleRepo = new Mock <IReferenceRepository <GasStationSchedule> >();
MockGasStationScheduleByDayRepo = new Mock <IReferenceRepository <GasStationScheduleByDay> >();
MockGasStationTanksScheduleRepo = new Mock <IReferenceRepository <GasStationTankSchedule> >();
MockDayComparable = new Mock <IDayComparable>();
MockTimeIntervalComparable = new Mock <ITimeIntervalComparable>();
MockGasStationScheduleByTimeRepo = new Mock <IReferenceRepository <GasStationScheduleByTime> >();
MockGasStationsRepo = new Mock <IReferenceRepository <GasStation> >();
MockManagerOrderRepository = new Mock <IManageOrderRepository>();
MockGasStationCustomRepository = new Mock <IGasStationRepository>();
MockGasStationScheduleRepo.Setup(x => x.FindByAsync(It.IsAny <Expression <Func <GasStationSchedule, bool> > >())).ReturnsAsync(
(Expression <Func <GasStationSchedule, bool> > predicate) => orderData.GasStationSchedules.Where(predicate.Compile()));
MockGasStationScheduleByDayRepo.Setup(x => x.FindByAsync(It.IsAny <Expression <Func <GasStationScheduleByDay, bool> > >()))
.ReturnsAsync((Expression <Func <GasStationScheduleByDay, bool> > predicate) =>
orderData.GasStationSchedulesByDay.Where(predicate.Compile())
);
MockGasStationTanksScheduleRepo.Setup(x => x.FindByAsync(It.IsAny <Expression <Func <GasStationTankSchedule, bool> > >()))
.ReturnsAsync((Expression <Func <GasStationTankSchedule, bool> > predicate) =>
orderData.GasStationTankSchedules.Where(predicate.Compile())
);
MockGasStationScheduleByTimeRepo.Setup(x => x.FindByAsync(It.IsAny <Expression <Func <GasStationScheduleByTime, bool> > >()))
.ReturnsAsync((Expression <Func <GasStationScheduleByTime, bool> > predicate) =>
orderData.GasStationSchedulesByTime.Where(predicate.Compile())
);
MockManagerOrderRepository.Setup(x => x.GetOrdersByGasStationIdAsync(
It.IsAny <Guid>())).ReturnsAsync((Guid gasStationId) =>
{
var manageOrder = new ManageOrder();
foreach (var ord in orderData.Orders.Where(x => x.GasStationId == gasStationId))
{
manageOrder.Add(ord);
}
return(manageOrder);
});
MockManagerOrderRepository.Setup(x => x.GetOrderByGasStationIdDeliveryDateAsync(
It.IsAny <Guid>(),
It.IsAny <DateTimeRange>())).ReturnsAsync((Guid gasStationId, DateTimeRange dispatchDate) =>
{
return(orderData.Orders.Where(x => x.GasStationId == gasStationId &&
x.DispatchDate == dispatchDate).First());
});
MockManagerOrderRepository.Setup(x => x.UpsertAsync(
It.IsAny <ManageOrder>())).Returns((ManageOrder manageOrder) =>
{
void insertOrder(Order order)
{
order.CreatedDate = DateTime.UtcNow;
order.ModifiedDate = DateTime.UtcNow;
orderData.AddOrder(order);
}
void updateOrder(Order order)
{
order.ModifiedDate = DateTime.UtcNow;
}
foreach (var order in manageOrder.Orders)
{
if (order.State == TrackingState.Added)
{
insertOrder(order);
}
else if (order.State == TrackingState.Modified)
{
updateOrder(order);
}
}
return(Task.CompletedTask);
});
MockGasStationCustomRepository
.Setup(x => x.GetGasStationIncludeTankOrderStrategyAsync(It.IsAny <Guid>()))
.ReturnsAsync((Guid gasStationId) =>
(orderData.GasStations.First(), orderData.OrderStrategies.First().OrderType)
);
MockGasStationsRepo.Setup(x => x.FindByAsync(It.IsAny <Expression <Func <GasStation, bool> > >()))
.ReturnsAsync((Expression <Func <GasStation, bool> > predicate) =>
orderData.GasStations.Where(predicate.Compile())
);
MockGasStationsRepo.Setup(x => x.FindByKeyAsync(It.IsAny <object>()))
.ReturnsAsync((object id) =>
orderData.GasStations.Where(x => x.Id == (Guid)id).First()
);
}
