public IActionResult PutPricingStrategyItem([FromRoute] int id, [FromBody] PricingStrategyItem pricingStrategyItem)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (id != pricingStrategyItem.Id)
{
return(BadRequest());
}
try
{
_unitOfWork.PricingStrategyItems.Update(pricingStrategyItem);
}
catch (DbUpdateConcurrencyException)
{
if (!PricingStrategyItemExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(NoContent());
}
public void Should_GetPricingStrategyItemById(int id)
{
using (ApplicationDbContext context = SeedContext())
{
var entity = new DbRepository <PricingStrategyItem>(context);
PricingStrategyItem getPricingStrategyItem = entity.GetById(id);
Assert.NotNull(getPricingStrategyItem);
}
}
public IActionResult PostPricingStrategyItem([FromBody] PricingStrategyItem pricingStrategyItem)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
_unitOfWork.PricingStrategyItems.Create(pricingStrategyItem);
return(CreatedAtAction("GetPricingStrategyItem", new { id = pricingStrategyItem.Id }, pricingStrategyItem));
}
public void Should_AddPricingStrategyItem()
{
using (ApplicationDbContext context = SeedContext())
{
PricingStrategyItem pricingStrategyItem = new PricingStrategyItem {
Name = "Test", Description = "Test", Price = 1, PricingStrategyId = 1
};
var entity = new DbRepository <PricingStrategyItem>(context);
bool created = entity.Create(pricingStrategyItem);
Assert.True(created);
}
}
public void Should_PutPricingStrategyItem()
{
PricingStrategyItem testPricingStrategyItem = new PricingStrategyItem {
Id = 1
};
Mock <IUnitOfWork> mock = new Mock <IUnitOfWork>();
mock.Setup(f => f.PricingStrategyItems.Update(testPricingStrategyItem)).Returns(true);
PricingStrategyItemsController controller = new PricingStrategyItemsController(mock.Object);
var pricingStrategyItems = controller.PutPricingStrategyItem(1, testPricingStrategyItem);
Assert.IsType <NoContentResult>(pricingStrategyItems);
}
public void Should_GetPricingStrategyItem()
{
PricingStrategyItem testPricingStrategyItem = new PricingStrategyItem {
Id = 1, Name = "Test1", Description = "Test", Price = 5, PricingStrategyId = 1
};
Mock <IUnitOfWork> mock = new Mock <IUnitOfWork>();
mock.Setup(f => f.PricingStrategyItems.GetById(1)).Returns(testPricingStrategyItem);
PricingStrategyItemsController controller = new PricingStrategyItemsController(mock.Object);
var pricingStrategyItem = controller.GetPricingStrategyItem(1);
Assert.IsType <OkObjectResult>(pricingStrategyItem);
}
public void ShouldNot_DeletePricingStrategyItem_NotFound()
{
PricingStrategyItem testPricingStrategyItem = new PricingStrategyItem {
Id = 10
};
Mock <IUnitOfWork> mock = new Mock <IUnitOfWork>();
mock.Setup(f => f.PricingStrategyItems.GetById(10)).Returns((PricingStrategyItem)null);
PricingStrategyItemsController controller = new PricingStrategyItemsController(mock.Object);
var result = controller.DeletePricingStrategyItem(10);
Assert.IsType <NotFoundResult>(result);
}
public void Should_PostPricingStrategyItem()
{
PricingStrategyItem testPricingStrategyItem = new PricingStrategyItem {
Id = 1, Name = "Test1", Description = "Test", Price = 5, PricingStrategyId = 1
};
Mock <IUnitOfWork> mock = new Mock <IUnitOfWork>();
mock.Setup(f => f.PricingStrategyItems.Create(testPricingStrategyItem)).Returns(true);
PricingStrategyItemsController controller = new PricingStrategyItemsController(mock.Object);
var pricingStrategyItems = controller.PostPricingStrategyItem(testPricingStrategyItem);
Assert.IsType <CreatedAtActionResult>(pricingStrategyItems);
}
public void Should_DeletePricingStrategyItem()
{
PricingStrategyItem testPricingStrategyItem = new PricingStrategyItem {
Id = 1
};
Mock <IUnitOfWork> mock = new Mock <IUnitOfWork>();
mock.Setup(f => f.PricingStrategyItems.GetById(1)).Returns(testPricingStrategyItem);
mock.Setup(f => f.PricingStrategyItems.Delete(testPricingStrategyItem)).Returns(true);
PricingStrategyItemsController controller = new PricingStrategyItemsController(mock.Object);
var result = controller.DeletePricingStrategyItem(1);
Assert.IsType <OkObjectResult>(result);
}
public void ShouldNot_PutPricingStrategyItem_ModelStateError()
{
PricingStrategyItem testPricingStrategyItem = new PricingStrategyItem {
Id = 1
};
Mock <IUnitOfWork> mock = new Mock <IUnitOfWork>();
mock.Setup(f => f.PricingStrategyItems.Update(testPricingStrategyItem)).Returns(true);
PricingStrategyItemsController controller = new PricingStrategyItemsController(mock.Object);
controller.ModelState.AddModelError("TestError", "Error");
var pricingStrategyItems = controller.PutPricingStrategyItem(1, testPricingStrategyItem);
Assert.IsType <BadRequestObjectResult>(pricingStrategyItems);
}
public void ShouldNot_PostPricingStrategyItem_ModelStateError()
{
PricingStrategyItem testPricingStrategyItem = new PricingStrategyItem {
Id = 1, Name = "Test1", Description = "Test", Price = 5, PricingStrategyId = 1
};
Mock <IUnitOfWork> mock = new Mock <IUnitOfWork>();
mock.Setup(f => f.PricingStrategyItems.Create(testPricingStrategyItem)).Returns(true);
mock.Setup(f => f.PricingStrategyItems.GetById(1)).Returns(testPricingStrategyItem);
PricingStrategyItemsController controller = new PricingStrategyItemsController(mock.Object);
controller.ModelState.AddModelError("TestError", "Error");
var pricingStrategyItems = controller.PostPricingStrategyItem(testPricingStrategyItem);
Assert.IsType <BadRequestObjectResult>(pricingStrategyItems);
}
public void Should_DeletePricingStrategyItem()
{
using (ApplicationDbContext context = SeedContext())
{
var entity = new DbRepository <PricingStrategyItem>(context);
var pricingStrategyItem = new PricingStrategyItem {
Id = 1
};
if (pricingStrategyItem == null)
{
Assert.True(false);
}
bool deleted = entity.Delete(pricingStrategyItem);
Assert.True(deleted);
}
}
public void Should_PricingStrategyItemExist()
{
using (ApplicationDbContext context = SeedContext())
{
var entity = new DbRepository <PricingStrategyItem>(context);
var pricingStrategyItem = new PricingStrategyItem {
Id = 1
};
if (pricingStrategyItem == null)
{
Assert.True(false);
}
bool exists = entity.Exists(pricingStrategyItem);
Assert.True(exists);
}
}
public IActionResult CreateBooking([FromBody] CreateBookingViewModel model)
{
// check to see if authenticated user has made request
Claim userClaim = HttpContext.User.Claims.SingleOrDefault(f => f.Type == "sub");
User user = null;
Customer customer = null;
if (userClaim != null)
{
user = _userManager.FindByNameAsync(userClaim.Value).Result;
if (user != null)
{
customer = _unitOfWork.Customers.Get().SingleOrDefault(f => f.UserId == user.Id);
}
}
// create/update customer details with those provided in model
bool customerIsNew = false;
if (customer == null)
{
// set email, since no user is attributed to account (unique email check not in place, since it's not linked to account)
customerIsNew = true;
customer = new Customer {
Id = 0, ContactEmail = model.Customer.ContactEmail
};
}
bool customerValid = false;
customer.Address1 = model.Customer.Address1;
customer.Address2 = model.Customer.Address2;
customer.Address3 = model.Customer.Address3;
customer.Address4 = model.Customer.Address4;
customer.Address5 = model.Customer.Address5;
customer.ContactPhone = model.Customer.ContactPhone;
customer.FirstName = model.Customer.FirstName;
customer.LastName = model.Customer.LastName;
if (customerIsNew)
{
customerValid = _unitOfWork.Customers.Create(customer);
}
else
{
customerValid = _unitOfWork.Customers.Update(customer);
}
// customer cannot be created, so return bad request
if (!customerValid)
{
return(BadRequest());
}
// use showing id to get showing details (incl pricing strategy and items)
Showing showing = _unitOfWork.Showings.Get().
Include(f => f.Event).
Include(f => f.Room).ThenInclude(f => f.Venue).
Include(f => f.PricingStrategy).
ThenInclude(f => f.PricingStrategyItems).
SingleOrDefault(f => f.Id == model.ShowingId);
// no showing found, so attempt to delete customer if new, and return bad request
if (showing == null)
{
if (customerIsNew)
{
_unitOfWork.Customers.Delete(customer);
}
return(BadRequest());
}
DateTime bookedDate = DateTime.UtcNow;
// build booking and items, and attempt creation
Booking newBooking = new Booking
{
BookedDate = bookedDate,
Status = BookingStatus.PaymentComplete,
AdditionalDetails = "",
ShowingId = model.ShowingId,
CustomerId = customer.Id,
BookingItems = new List <BookingItem>()
};
foreach (var item in model.BookingItems)
{
// get the pricing strategy item if it exists, and if not cancel and return bad request
PricingStrategyItem pricingItem = showing.PricingStrategy.PricingStrategyItems.SingleOrDefault(f => f.Id == item.PricingStrategyItemId);
if (pricingItem == null)
{
if (customerIsNew)
{
_unitOfWork.Customers.Delete(customer);
}
return(BadRequest());
}
newBooking.BookingItems.Add(new BookingItem
{
AgreedPrice = pricingItem.Price,
AgreedPriceName = pricingItem.Name,
Location = item.Location
});
}
// attempt booking creation (all or nothing, since a pre-booking reservation mechanism is not implemented)
bool bookingCompleted = _unitOfWork.Bookings.Create(newBooking);
// simple "yay or nay" response (this can further improved by building better error checking/scrapping 'UoW' wrapper)
if (!bookingCompleted)
{
return(BadRequest());
}
// send email confirming details of the booking
StringBuilder emailContent = new StringBuilder();
emailContent.Append($"Thank you for booking with us! The details of your booking can be found below:\n\n");
emailContent.Append($"Booking Date: {bookedDate.ToLongDateString()}\n\n");
emailContent.Append($"Event: {showing.Event.Name}\n");
emailContent.Append($"Venue: {showing.Room.Venue.Name}\n");
emailContent.Append($"Room: {showing.Room.Name}\n");
// use local time, since there's no user/venue timezone data to offset UTC time against
emailContent.Append($"Start Time: {showing.StartTime.ToLocalTime().ToString()}\n\n");
emailContent.Append("Admissions\n");
emailContent.Append("----------------------------------------------------\n\n");
emailContent.Append("Name\t\tPrice\t\tSeat\n");
emailContent.Append("----------------------------------------------------\n\n");
foreach (BookingItem item in newBooking.BookingItems)
{
// calcuate location string using location row and column (calculate first using room data)
int roomColumns = showing.Room.Columns;
int row = item.Location / roomColumns;
int column = item.Location % roomColumns;
string locationName = calculateLocationName(row, column);
emailContent.Append($"{item.AgreedPriceName}\t\t£{item.AgreedPrice}\t\t{locationName}\n");
}
emailContent.Append("----------------------------------------------------\n");
emailContent.Append($"Total\t\t£{newBooking.BookingItems.Sum(f => f.AgreedPrice).ToString("F2")}");
_emailService.SendEmail(customer.ContactEmail, "Booking Details", emailContent.ToString());
return(Ok());
}
