public async Task SeedAsync(CinemaDbContext context)
{
if (context.FilmProjections.Any())
{
return;
}
var projection = new FilmProjection
{
CinemaId = context.Cinemas.First().Id,
Date = DateTime.UtcNow.AddDays(10),
FilmId = context.Films.First().Id,
ProjectionType = ProjectionType._3D,
TotalTickets = 100,
TicketPrices = new TicketPrices
{
AdultPrice = 15,
StudentPrice = 10,
ChildrenPrice = 5,
},
};
await context.FilmProjections.AddAsync(projection);
await context.SaveChangesAsync();
}
public async Task <IActionResult> Edit(string id,
[Bind("Id,Date,ProjecitonType,TotalTickets,FilmId, TicketPrices")] FilmProjection projection)
{
var projectionInContext = await filmProjectionBusiness.GetAsync(id);
if (id != projection.Id || projectionInContext == null)
{
return(NotFound());
}
if (!ModelState.IsValid)
{
var films = filmDataBusiness.GetAll().ToList().OrderBy(x => x.Title).
ToDictionary(x => x.FilmId, x => x.Title);
ViewBag.SelectListOfFilms = new SelectList(films, "Key", "Value");
return(View(projection));
}
var ticketUrlPattern = Url.ActionLink("Index", "Tickets");
var projecitonsUrlPattern = Url.ActionLink("Index", "Projections");
projection.CinemaId = projectionInContext.CinemaId;
await filmProjectionBusiness.UpdateAsync(projection, projecitonsUrlPattern, ticketUrlPattern);
return(RedirectToAction(nameof(Details), new { id }));
}
///<summary>
/// Converts filmProjection object to ProjectionInputModel
///</summary>
///<param name="filmProjection"> FilmProjection object to map from</param>
///<returns>Mapped instance of type <see cref="ProjectionInputModel"/></returns>
public ProjectionInputModel MapToProjectionInputModel(FilmProjection filmProjection)
{
return(new ProjectionInputModel
{
Date = filmProjection.Date,
FilmTitle = filmProjection.Film.FilmData.Title,
ProjectionType = filmProjection.ProjectionType,
TotalTickets = filmProjection.TotalTickets,
ChildrenTicketPrice = filmProjection.TicketPrices.ChildrenPrice,
AdultsTicketPrice = filmProjection.TicketPrices.AdultPrice,
StudentsTicketPrice = filmProjection.TicketPrices.StudentPrice
});
}
///<summary>
/// Converts filmProjection object to ProjectionCardViewModel
///</summary>
///<param name="filmProjection"> FilmProjection object to map from</param>
///<returns>Mapped instance of type <see cref="ProjectionCardViewModel"/></returns>
public ProjectionCardViewModel MapToProjectionCardViewModel(FilmProjection filmProjection)
{
return(new ProjectionCardViewModel
{
Id = filmProjection.Id,
CinemaName = filmProjection.Cinema.Name,
FilmTitle = filmProjection.Film.FilmData.Title,
ProjectionType = filmProjection.ProjectionType,
Date = filmProjection.Date,
CinemaCity = filmProjection.Cinema.City,
CinemaCountry = filmProjection.Cinema.Country
});
}
/// <summary>
/// Sends email to inform about ticket information update
/// </summary>
/// <param name="reciever">Email of the reciever</param>
/// <param name="projection">Projection data about the one that is canceled</param>
/// <param name="ticketsUrlPattern">Url of the rickets reference page</param>
public async Task SendTicketUpdateEmailAsync(string reciever,
FilmProjection projection,
string ticketsUrlPattern)
{
ticketsUrlPattern = HtmlEncoder.Default.Encode(ticketsUrlPattern);
var subject = "Ticket update alert";
var html = $"<p style=\"color: #000\">We inform you that your ticket for the {projection.Film.FilmData.Title}" +
$" in cinema \"{projection.Cinema.Name}\" on {projection.Date.ToString("dd/MM/yyyy HH/mm")} has been updated" +
$" due to projection changes.</p> </br> " +
$"<p> You can go and see your new ticket or you can cancel it by clicking " +
$"<a href=\"{ticketsUrlPattern}\">here</a></p>";
await SendEmailAsync(reciever, subject, html);
}
/// <summary>
/// Sends email to cancel a ticket reservation for a selected projection
/// </summary>
/// <param name="reciever">Email of the reciever</param>
/// <param name="projection">Projection data about the one that is canceled</param>
/// <param name="projectionsUrlPattern">Url of the projections reference page</param>
public async Task SendTicketCancelationEmailAsync(string reciever,
FilmProjection projection,
string projectionsUrlPattern)
{
var subject = "Ticket cancellation alert";
projectionsUrlPattern = HtmlEncoder.Default.Encode(projectionsUrlPattern);
var html = $"<p style=\"color: #000\">Regret to inform you that your ticket for the {projection.Film.FilmData.Title}" +
$" in cinema \"{projection.Cinema.Name}\" on {projection.Date.ToString("dd/MM/yyyy HH/mm")} has been canceled" +
$" due to projection cancelation.</p> " +
$"</br> <p> You can go and reserve a new one for a projection you'd like by clicking" +
$" <a href=\"{projectionsUrlPattern}\">here</a></p>";
await SendEmailAsync(reciever, subject, html);
}
///<summary>
/// Updates information about users' tickets with selected parameters
///</summary>
///<param name="userId">Id of the user</param>
///<param name="input">Ticket information</param>
///<param name="projection">Projection information</param>
///<param name="DateTime">Ticket time paramater</param>
///<returns>Mapped instance of type <see cref="ProjectionTicket"/></returns>
public ProjectionTicket MapToProjectionTicket(string userId,
TicketInputModel input,
FilmProjection projection,
DateTime timeStamp)
{
return(new ProjectionTicket
{
ProjectionId = projection.Id,
Seat = input.Seat,
Type = input.TicketType,
Price = (double)projection.TicketPrices.GetType().
GetProperty($"{input.TicketType.ToString()}Price").
GetValue(projection.TicketPrices),
HolderId = userId,
ReservedOn = timeStamp
});
}
///<summary>
/// Converts FilmProjection object to ProjectionDataViewModel
///</summary>
///<param name="dilmProjcetion"> FilmProjection object to map from </param>
///<returns>Mapped instance of type <see cref="ProjectionDataViewModel"/></returns>
public ProjectionDataViewModel MapToProjectionDataViewModel(FilmProjection filmProjection)
{
return(new ProjectionDataViewModel
{
Id = filmProjection.Id,
CinemaName = filmProjection.Cinema.Name,
FilmTitle = filmProjection.Film.FilmData.Title,
ProjectionType = filmProjection.ProjectionType,
Date = filmProjection.Date,
TotalTickets = filmProjection.TotalTickets,
FilmRuntime = filmProjection.Film.FilmData.Runtime,
FilmTargetAudience = filmProjection.Film.FilmData.TargetAudience,
CinemaCity = filmProjection.Cinema.City,
CinemaCountry = filmProjection.Cinema.Country,
TicketsSold = filmProjection.ProjectionTickets.Count(),
ChildrenTicketPrice = filmProjection.TicketPrices.ChildrenPrice,
AdultsTicketPrice = filmProjection.TicketPrices.AdultPrice,
StudentsTicketPrice = filmProjection.TicketPrices.StudentPrice,
FilmId = filmProjection.FilmId,
CinemaId = filmProjection.CinemaId,
});
}
public async Task AddAddsElementToDb()
{
// Arrange
var projections = new List <FilmProjection>
{
new FilmProjection {
},
new FilmProjection {
}
}.AsQueryable();
var mockSet = new Mock <DbSet <FilmProjection> >();
mockSet.As <IQueryable <FilmProjection> >().Setup(m => m.Provider).Returns(projections.Provider);
mockSet.As <IQueryable <FilmProjection> >().Setup(m => m.Expression).Returns(projections.Expression);
mockSet.As <IQueryable <FilmProjection> >().Setup(m => m.ElementType).Returns(projections.ElementType);
mockSet.As <IQueryable <FilmProjection> >().Setup(m => m.GetEnumerator()).
Returns(projections.GetEnumerator());
var mockContext = new Mock <CinemaDbContext>();
mockContext.Setup(c => c.FilmProjections).Returns(mockSet.Object);
mockContext.Setup(m => m.AddAsync(It.IsAny <FilmProjection>(), It.IsAny <CancellationToken>()))
.Returns(new ValueTask <EntityEntry <FilmProjection> >
(Task.FromResult((EntityEntry <FilmProjection>)null)));
var projectionBusiness = new FilmProjectionBusiness(mockContext.Object,
new EmailSender("TestAPIKey",
"TestSender",
"TestSenderName"));
var projection = new FilmProjection();
var mapper = new Mapper();
// Act
await projectionBusiness.AddAsync(projection);
// Assert
mockSet.Verify(m => m.AddAsync(It.IsAny <FilmProjection>(), It.IsAny <CancellationToken>()), Times.Once());
mockContext.Verify(m => m.SaveChangesAsync(It.IsAny <CancellationToken>()), Times.Once());
}
/// <summary>
/// Updates information for a selected projection
/// and send email to infrom about the update
/// </summary>
/// <param name="projection">New projection object</param>
/// <param name="projectionsUrlPattern">Projection page reference url</param>
/// <param name="ticketsUrlPattern">Tickets page reference url</param>
public async Task UpdateAsync(FilmProjection projection, string projectionsUrlPattern, string ticketsUrlPattern)
{
var projectionInContext = await context.FilmProjections.FindAsync(projection.Id);
if (projectionInContext != null)
{
foreach (var ticket in context.ProjectionTickets.Where(x => x.ProjectionId == projection.Id).ToList())
{
if (ticket.Seat > projection.TotalTickets)
{
await emailSender.SendTicketCancelationEmailAsync(ticket.Holder.Email,
projectionInContext,
projectionsUrlPattern);
context.ProjectionTickets.Remove(ticket);
}
else
{
switch (ticket.Type)
{
case TicketType.Adult: ticket.Price = projection.TicketPrices.AdultPrice; break;
case TicketType.Children: ticket.Price = projection.TicketPrices.ChildrenPrice; break;
case TicketType.Student: ticket.Price = projection.TicketPrices.StudentPrice; break;
}
await emailSender.SendTicketUpdateEmailAsync(ticket.Holder.Email,
projectionInContext,
ticketsUrlPattern);
}
}
context.Entry(projectionInContext).CurrentValues.SetValues(projection);
projectionInContext.TicketPrices.AdultPrice = projection.TicketPrices.AdultPrice;
projectionInContext.TicketPrices.StudentPrice = projection.TicketPrices.StudentPrice;
projectionInContext.TicketPrices.ChildrenPrice = projection.TicketPrices.ChildrenPrice;
await context.SaveChangesAsync();
}
}
/// <summary>
/// Adds new projection
/// </summary>
/// <param name="filmProjection">New projection object</param>
public async Task AddAsync(FilmProjection filmProjection)
{
await context.FilmProjections.AddAsync(filmProjection);
await context.SaveChangesAsync();
}
