public async Task <ProjectionDomainModel> UpdateProjection(ProjectionDomainModel dataToUpdate)
{
Projection projection = new Projection()
{
Id = dataToUpdate.Id,
AuditoriumId = dataToUpdate.AuditoriumId,
MovieId = dataToUpdate.MovieId,
DateTime = dataToUpdate.ProjectionTime
};
var data = _projectionsRepository.Update(projection);
if (data == null)
{
return(null);
}
_projectionsRepository.Save();
ProjectionDomainModel domainModel = new ProjectionDomainModel()
{
Id = data.Id,
AuditoriumId = data.AuditoriumId,
MovieId = data.MovieId,
ProjectionTime = data.DateTime
};
return(domainModel);
}
public async Task <IEnumerable <ProjectionDomainModel> > GetProjectionByAuditoriumIdMovieId(int auditoriumId, Guid movieId)
{
var data = _projectionsRepository.GetByAuditoriumIdMovieId(auditoriumId, movieId);
if (data == null)
{
return(null);
}
List <ProjectionDomainModel> domainModelList = new List <ProjectionDomainModel>();
foreach (Projection projection in data)
{
ProjectionDomainModel domainModel = new ProjectionDomainModel
{
Id = projection.Id,
AuditoriumId = projection.AuditoriumId,
MovieId = projection.MovieId,
ProjectionTime = projection.DateTime,
AuditoriumName = projection.Auditorium.Name
};
domainModelList.Add(domainModel);
}
return(domainModelList);
}
public void Get_By_Projection_Id_Return_Projection()
{
//Assert
int expectedStatusCode = 200;
ProjectionDomainModel projectionDomainModel = new ProjectionDomainModel
{
Id = Guid.NewGuid(),
AuditoriumName = "Auditorium123",
AuditoriumId = 2,
MovieId = Guid.NewGuid(),
MovieTitle = "Film",
ProjectionTime = new DateTime()
};
Task <ProjectionDomainModel> responseTask = Task.FromResult(projectionDomainModel);
_projectionService = new Mock <IProjectionService>();
_projectionService.Setup(x => x.GetProjectionByIdAsync(It.IsAny <Guid>())).Returns(responseTask);
ProjectionsController projectionsController = new ProjectionsController(_projectionService.Object);
//Act
var result = projectionsController.GetById(projectionDomainModel.Id).ConfigureAwait(false).GetAwaiter().GetResult().Result;
var resultValue = ((OkObjectResult)result).Value;
var projectionDomainModelResult = (ProjectionDomainModel)resultValue;
//Assert
Assert.IsNotNull(projectionDomainModelResult);
Assert.AreEqual(projectionDomainModel.Id, projectionDomainModelResult.Id);
Assert.IsInstanceOfType(result, typeof(OkObjectResult));
Assert.AreEqual(expectedStatusCode, ((OkObjectResult)result).StatusCode);
}
public void Get_By_Projection_Id_Return_Not_Found()
{
//Arrange
int expectedStatusCode = 404;
string expectedMessage = Messages.PROJECTION_DOES_NOT_EXIST;
ProjectionDomainModel projectionDomainModel = null;
Task <ProjectionDomainModel> responseTask = Task.FromResult(projectionDomainModel);
_projectionService = new Mock <IProjectionService>();
_projectionService.Setup(x => x.GetProjectionByIdAsync(It.IsAny <Guid>())).Returns(responseTask);
ProjectionsController projectionsController = new ProjectionsController(_projectionService.Object);
//Act
var result = projectionsController.GetById(Guid.NewGuid()).ConfigureAwait(false).GetAwaiter().GetResult().Result;
var resultValue = ((NotFoundObjectResult)result).Value;
var messageReturned = (string)resultValue;
//Assert
Assert.IsNotNull(messageReturned);
Assert.AreEqual(expectedMessage, messageReturned);
Assert.IsInstanceOfType(result, typeof(NotFoundObjectResult));
Assert.AreEqual(expectedStatusCode, ((NotFoundObjectResult)result).StatusCode);
}
public async Task <IEnumerable <ProjectionDomainModel> > GetProjectionsByAuditoriumId(int id)
{
var data = _projectionsRepository.GetByAuditoriumId(id);
if (data == null)
{
return(null);
}
List <ProjectionDomainModel> domainModelList = new List <ProjectionDomainModel>();
foreach (Projection projection in data)
{
ProjectionDomainModel domainModel = new ProjectionDomainModel
{
Id = projection.Id,
AuditoriumId = projection.AuditoriumId,
MovieId = projection.MovieId,
ProjectionTime = projection.DateTime,
AuditoriumName = projection.Auditorium.Name,
MovieTitle = projection.Movie.Title,
MovieRating = projection.Movie.Rating,
MovieYear = projection.Movie.Year
};
domainModelList.Add(domainModel);
}
return(domainModelList);
}
public async Task <IEnumerable <ProjectionDomainModel> > GetAllAsync()
{
var data = await _projectionsRepository.GetAll();
if (data == null)
{
return(null);
}
List <ProjectionDomainModel> result = new List <ProjectionDomainModel>();
ProjectionDomainModel model;
foreach (var item in data)
{
model = new ProjectionDomainModel
{
Id = item.Id,
MovieId = item.MovieId,
AuditoriumId = item.AuditoriumId,
ProjectionTime = item.DateTime,
MovieTitle = item.Movie.Title,
AuditoriumName = item.Auditorium.Name
};
result.Add(model);
}
return(result);
}
public async Task <ProjectionDomainModel> GetFullProjectionByIdAsync(Guid id)
{
var data = await _projectionsRepository.GetByIdAsync(id);
if (data == null)
{
return(null);
}
//_movieService
// MovieDomainModel movie = await _movieService.GetMovieByIdAsync(data.MovieId);
//Movie movie = nadjiPreko servisa
// Auditorium name = nadji preko servisa
ProjectionDomainModel domainModel = new ProjectionDomainModel
{
Id = data.Id,
AuditoriumId = data.AuditoriumId,
// AuditoriumName = data.Auditorium.Name,
MovieId = data.MovieId,
ProjectionTime = data.DateTime,
// MovieTitle = movie.Title,
// MovieYear = movie.Year,
// MovieRating = movie.Rating
};
return(domainModel);
}
public void TestInitialize()
{
_projection = new Projection
{
Id = Guid.NewGuid(),
Auditorium = new Auditorium {
Name = "ImeSale"
},
Movie = new Movie {
Title = "ImeFilma"
},
MovieId = Guid.NewGuid(),
DateTime = DateTime.Now.AddDays(1),
AuditoriumId = 1
};
_projectionDomainModel = new ProjectionDomainModel
{
Id = Guid.NewGuid(),
AditoriumName = "ImeSale",
AuditoriumId = 1,
MovieId = Guid.NewGuid(),
MovieTitle = "ImeFilma",
ProjectionTime = DateTime.Now.AddDays(1)
};
List <Projection> projectionsModelsList = new List <Projection>();
projectionsModelsList.Add(_projection);
IEnumerable <Projection> projections = projectionsModelsList;
Task <IEnumerable <Projection> > responseTask = Task.FromResult(projections);
_mockProjectionsRepository = new Mock <IProjectionsRepository>();
_mockProjectionsRepository.Setup(x => x.GetAll()).Returns(responseTask);
}
public async Task <ProjectionDomainModel> DeleteProjection(Guid id)
{
var reservationData = _reservationService.DeleteByProjectionId(id);
if (reservationData == null)
{
return(null);
}
var data = _projectionsRepository.Delete(id);
if (data == null)
{
return(null);
}
_projectionsRepository.Save();
ProjectionDomainModel domainModel = new ProjectionDomainModel
{
Id = data.Id,
MovieId = data.MovieId,
AuditoriumId = data.AuditoriumId,
ProjectionTime = data.DateTime
};
return(domainModel);
}
public async Task <CreateProjectionResultModel> CreateProjection(ProjectionDomainModel domainModel)
{
int projectionTime = 3;
var projectionsAtSameTime = _projectionsRepository.GetByAuditoriumId(domainModel.AuditoriumId)
.Where(x => x.DateTime <domainModel.ProjectionTime.AddHours(projectionTime) && x.DateTime> domainModel.ProjectionTime.AddHours(-projectionTime))
.ToList();
if (projectionsAtSameTime != null && projectionsAtSameTime.Count > 0)
{
return(new CreateProjectionResultModel
{
IsSuccessful = false,
ErrorMessage = Messages.PROJECTIONS_AT_SAME_TIME
});
}
var newProjection = new Data.Projection
{
MovieId = domainModel.MovieId,
AuditoriumId = domainModel.AuditoriumId,
DateTime = domainModel.ProjectionTime
};
var insertedProjection = _projectionsRepository.Insert(newProjection);
if (insertedProjection == null)
{
return(new CreateProjectionResultModel
{
IsSuccessful = false,
ErrorMessage = Messages.PROJECTION_CREATION_ERROR
});
}
_projectionsRepository.Save();
var projekcija = await _projectionsRepository.GetByIdAsync(insertedProjection.Id);
CreateProjectionResultModel result = new CreateProjectionResultModel
{
IsSuccessful = true,
ErrorMessage = null,
Projection = new ProjectionDomainModel
{
Id = insertedProjection.Id,
AuditoriumId = insertedProjection.AuditoriumId,
MovieId = insertedProjection.MovieId,
ProjectionTime = insertedProjection.DateTime,
AuditoriumName = projekcija.Auditorium.AuditName,
MovieTitle = projekcija.Movie.Title
}
};
return(result);
}
public async Task <ActionResult <ProjectionDomainModel> > GetById(Guid id)
{
ProjectionDomainModel projectionModel = await _projectionService.GetProjectionByIdAsync(id);
if (projectionModel == null)
{
return(NotFound(Messages.PROJECTION_DOES_NOT_EXIST));
}
return(Ok(projectionModel));
}
public void TestInitialize()
{
_projection = new Projection
{
Id = Guid.NewGuid(),
Auditorium = new Auditorium {
Name = "ImeSale"
},
Movie = new Movie {
Title = "ImeFilma"
},
MovieId = Guid.NewGuid(),
DateTime = DateTime.Now.AddDays(1),
AuditoriumId = 1
};
_projectionDomainModel = new ProjectionDomainModel
{
Id = _projection.Id,
AuditoriumName = "ImeSale",
AuditoriumId = 1,
MovieId = Guid.NewGuid(),
MovieTitle = "ImeFilma",
ProjectionTime = DateTime.Now.AddDays(1)
};
_reservationDomainModel = new ReservationDomainModel
{
ProjectionId = _projection.Id,
SeatId = Guid.NewGuid(),
UserId = Guid.NewGuid()
};
List <Projection> projectionsModelsList = new List <Projection>();
projectionsModelsList.Add(_projection);
IEnumerable <Projection> projections = projectionsModelsList;
Task <IEnumerable <Projection> > responseTask = Task.FromResult(projections);
_mockProjectionsRepository = new Mock <IProjectionsRepository>();
_mockProjectionsRepository.Setup(x => x.GetAll()).Returns(responseTask);
List <ReservationDomainModel> reservationDomainModelsList = new List <ReservationDomainModel>();
reservationDomainModelsList.Add(_reservationDomainModel);
IEnumerable <ReservationDomainModel> reservations = reservationDomainModelsList;
Task <IEnumerable <ReservationDomainModel> > reservationResponseTask = Task.FromResult(reservations);
_mockReservationService = new Mock <IReservationService>();
_mockReservationService.Setup(x => x.DeleteByProjectionId(It.IsAny <Guid>())).Returns(reservationResponseTask);
}
public async Task <IEnumerable <ProjectionDomainModel> > GetProjectionsByReservationIds(IEnumerable <ReservationDomainModel> reservationDomainModels)
{
List <ProjectionDomainModel> result = new List <ProjectionDomainModel>();
foreach (ReservationDomainModel reservation in reservationDomainModels)
{
ProjectionDomainModel projection = await GetFullProjectionByIdAsync(reservation.ProjectionId);
result.Add(projection);
}
return(result);
}
//[Authorize(Roles = "admin")]
public async Task <ActionResult <ProjectionDomainModel> > PostAsync(CreateProjectionModel projectionModel)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (projectionModel.ProjectionTime < DateTime.Now)
{
ModelState.AddModelError(nameof(projectionModel.ProjectionTime), Messages.PROJECTION_IN_PAST);
return(BadRequest(ModelState));
}
ProjectionDomainModel domainModel = new ProjectionDomainModel
{
AuditoriumId = projectionModel.AuditoriumId,
MovieId = projectionModel.MovieId,
ProjectionTime = projectionModel.ProjectionTime
};
CreateProjectionResultModel createProjectionResultModel;
try
{
createProjectionResultModel = await _projectionService.CreateProjection(domainModel);
}
catch (DbUpdateException e)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = e.InnerException.Message ?? e.Message,
StatusCode = System.Net.HttpStatusCode.BadRequest
};
return(BadRequest(errorResponse));
}
if (!createProjectionResultModel.IsSuccessful)
{
ErrorResponseModel errorResponse = new ErrorResponseModel
{
ErrorMessage = createProjectionResultModel.ErrorMessage,
StatusCode = System.Net.HttpStatusCode.BadRequest
};
return(BadRequest(errorResponse));
}
return(Created("projections//" + createProjectionResultModel.Projection.Id, createProjectionResultModel.Projection));
}
public IEnumerable <MovieDomainModel> GetAllCurrentMovies()
{
var data = _moviesRepository.GetCurrentMovies();
if (data == null)
{
return(null);
}
List <MovieDomainModel> result = new List <MovieDomainModel>();
MovieDomainModel model;
foreach (Movie movie in data)
{
List <ProjectionDomainModel> listOfProjs = new List <ProjectionDomainModel>();
if (movie.Projections != null)
{
foreach (Projection projection in movie.Projections)
{
ProjectionDomainModel projModel = new ProjectionDomainModel
{
Id = projection.Id,
MovieId = projection.MovieId,
MovieTitle = projection.Movie.Title,
AuditoriumId = projection.AuditoriumId,
ProjectionTime = projection.DateTime,
};
listOfProjs.Add(projModel);
}
}
model = new MovieDomainModel
{
Current = movie.Current,
Id = movie.Id,
Rating = movie.Rating ?? 0,
Title = movie.Title,
Year = movie.Year,
Projections = listOfProjs,
BannerUrl = movie.BannerUrl
};
result.Add(model);
}
return(result);
}
//Projection filter by: Auditorium, Cinema, Movie, TimeSpan
public async Task <IEnumerable <ProjectionDomainModel> > GetAllAsync(ProjectionQuery query)
{
var data = await _projectionsRepository.GetAll();
if (query.AuditoriumId > 0)
{
data = data.Where(x => x.AuditoriumId == query.AuditoriumId);
}
if (query.CinemaId > 0)
{
data = data.Where(x => x.Auditorium.Cinema.Id == query.CinemaId);
}
if (query.MovieId != Guid.Empty)
{
data = data.Where(x => x.MovieId == query.MovieId);
}
if (query.DateLaterThan.HasValue)
{
data = data.Where(x => x.DateTime > query.DateLaterThan);
}
if (query.DateEarlierThan.HasValue)
{
data = data.Where(x => x.DateTime < query.DateEarlierThan);
}
List <ProjectionDomainModel> result = new List <ProjectionDomainModel>();
ProjectionDomainModel model;
foreach (var item in data)
{
model = new ProjectionDomainModel
{
Id = item.Id,
MovieId = item.MovieId,
AuditoriumId = item.AuditoriumId,
ProjectionTime = item.DateTime,
MovieTitle = item.Movie.Title,
AuditoriumName = item.Auditorium.AuditName
};
result.Add(model);
}
return(result);
}
public async Task <IEnumerable <ProjectionDomainModel> > DeleteByAuditoriumId(int auditoriumId)
{
var projectionModelsByAuditoriumId = _projectionsRepository.GetByAuditoriumId(auditoriumId);
if (projectionModelsByAuditoriumId == null)
{
return(null);
}
projectionModelsByAuditoriumId.ToList();
List <Projection> deletedProjections = new List <Projection>();
foreach (Projection projection in projectionModelsByAuditoriumId)
{
var deletedReservations = await _reservationService.DeleteByProjectionId(projection.Id);
if (deletedReservations == null)
{
return(null);
}
deletedReservations.ToList();
var deletedProjection = _projectionsRepository.Delete(projection.Id);
if (deletedProjection == null)
{
return(null);
}
deletedProjections.Add(deletedProjection);
}
List <ProjectionDomainModel> domainModelList = new List <ProjectionDomainModel>();
foreach (Projection projection in deletedProjections)
{
ProjectionDomainModel domainModel = new ProjectionDomainModel
{
Id = projection.Id,
AuditoriumId = projection.AuditoriumId,
MovieId = projection.MovieId,
ProjectionTime = projection.DateTime
};
domainModelList.Add(domainModel);
}
return(domainModelList);
}
public async Task <IEnumerable <ProjectionDomainModel> > GetAllAsyncForSpecificMovie(Guid id)
{
var data = await _projectionsRepository.GetAllFromOneMovie(id);
List <ProjectionDomainModel> result = new List <ProjectionDomainModel>();
if (data == null)
{
return(null);
}
ProjectionDomainModel model;
foreach (var item in data)
{
model = new ProjectionDomainModel
{
Id = item.Id,
MovieId = item.MovieId,
AuditoriumId = item.AuditoriumId,
ProjectionTimeString = item.DateTime.ToString("hh:mm tt"),
MovieTitle = item.Movie.Title,
AuditoriumName = item.Auditorium.Name
};
List <Seat> listaSeat = new List <Seat>();
var seatsForThisAuditorium = await _seatsRepository.GetAllOfSpecificAuditoriumForProjection(model.AuditoriumId);
var row = 0;
var seatPerRow = 0;
foreach (var seatInAuditorium in seatsForThisAuditorium)
{
listaSeat.Add(seatInAuditorium);
}
foreach (var seat in listaSeat)
{
row = seat.Row;
seatPerRow = seat.Number;
}
model.NumOFRows = row;
model.NumOFSeatsPerRow = seatPerRow;
result.Add(model);
}
return(result);
}
public async Task <ProjectionDomainModel> GetProjectionByIdAsync(Guid id)
{
var data = await _projectionsRepository.GetByIdAsync(id);
if (data == null)
{
return(null);
}
ProjectionDomainModel domainModel = new ProjectionDomainModel
{
Id = data.Id,
AuditoriumId = data.AuditoriumId,
MovieId = data.MovieId,
ProjectionTime = data.DateTime
};
return(domainModel);
}
public async Task <ProjectionDomainModel> GetProjectionByIdAsync(Guid id)
{
var projection = await _projectionsRepository.GetByIdAsync(id);
if (projection == null)
{
return(null);
}
ProjectionDomainModel projectionModel = new ProjectionDomainModel
{
Id = projection.Id,
MovieId = projection.MovieId,
AuditoriumName = projection.Auditorium.AuditName,
AuditoriumId = projection.AuditoriumId,
MovieTitle = projection.Movie.Title,
ProjectionTime = projection.DateTime
};
return(projectionModel);
}
public void GetAsync_Return_All_Projections()
{
//Arrange
List <ProjectionDomainModel> projectionsDomainModelsList = new List <ProjectionDomainModel>();
ProjectionDomainModel projectionDomainModel = new ProjectionDomainModel
{
Id = Guid.NewGuid(),
AuditoriumName = "ImeSale",
AuditoriumId = 1,
MovieId = Guid.NewGuid(),
MovieTitle = "ImeFilma",
ProjectionTime = DateTime.Now.AddDays(1)
};
query = new ProjectionQuery();
projectionsDomainModelsList.Add(projectionDomainModel);
IEnumerable <ProjectionDomainModel> projectionDomainModels = projectionsDomainModelsList;
Task <IEnumerable <ProjectionDomainModel> > responseTask = Task.FromResult(projectionDomainModels);
int expectedResultCount = 1;
int expectedStatusCode = 200;
_projectionService = new Mock <IProjectionService>();
_projectionService.Setup(x => x.GetAllAsync(query)).Returns(responseTask);
ProjectionsController projectionsController = new ProjectionsController(_projectionService.Object);
//Act
var result = projectionsController.GetAsync(query).ConfigureAwait(false).GetAwaiter().GetResult().Result;
var resultList = ((OkObjectResult)result).Value;
var projectionDomainModelResultList = (List <ProjectionDomainModel>)resultList;
//Assert
Assert.IsNotNull(projectionDomainModelResultList);
Assert.AreEqual(expectedResultCount, projectionDomainModelResultList.Count);
Assert.AreEqual(projectionDomainModel.Id, projectionDomainModelResultList[0].Id);
Assert.IsInstanceOfType(result, typeof(OkObjectResult));
Assert.AreEqual(expectedStatusCode, ((OkObjectResult)result).StatusCode);
}
public void TestInitialize()
{
_auditorium = new Auditorium
{
Id = 1,
CinemaId = 1,
Name = "AuditoriumIme",
Cinema = new Data.Cinema {
Name = "Bioskop"
}
};
_auditoriumDomainModel = new AuditoriumDomainModel
{
Id = _auditorium.Id,
CinemaId = _auditorium.CinemaId,
Name = _auditorium.Name
};
_projectionDomainModel = new ProjectionDomainModel
{
AuditoriumId = _auditoriumDomainModel.Id,
Id = Guid.NewGuid(),
AuditoriumName = _auditoriumDomainModel.Name,
MovieId = Guid.NewGuid(),
MovieRating = 1,
MovieTitle = "imefilmea",
MovieYear = 1992,
ProjectionTime = DateTime.Now.AddDays(1)
};
_seatDomainModel = new SeatDomainModel
{
Id = Guid.NewGuid(),
AuditoriumId = _auditoriumDomainModel.Id,
Row = 1,
Number = 1
};
List <Auditorium> auditoriumsModelsList = new List <Auditorium>();
auditoriumsModelsList.Add(_auditorium);
IEnumerable <Auditorium> auditoriums = auditoriumsModelsList;
Task <IEnumerable <Auditorium> > responseTask = Task.FromResult(auditoriums);
List <ProjectionDomainModel> projectionsModelsList = new List <ProjectionDomainModel>();
projectionsModelsList.Add(_projectionDomainModel);
IEnumerable <ProjectionDomainModel> projections = projectionsModelsList;
Task <IEnumerable <ProjectionDomainModel> > projectionsResponseTask = Task.FromResult(projections);
List <SeatDomainModel> seatsModelsList = new List <SeatDomainModel>();
seatsModelsList.Add(_seatDomainModel);
IEnumerable <SeatDomainModel> seats = seatsModelsList;
Task <IEnumerable <SeatDomainModel> > seatsResponseTask = Task.FromResult(seats);
_mockAuditoriumsRepository = new Mock <IAuditoriumsRepository>();
_mockProjectionService = new Mock <IProjectionService>();
_mockSeatService = new Mock <ISeatService>();
}
