public bool Validation(CreateMovieDTO request)
{
foreach (var actorId in request.ActorsIds)
{
var actor = context.Actors.Find(actorId);
if (actor == null)
{
throw new EntityNotFoundException("Glumac nije proandjen");
}
}
foreach (var genreId in request.GenresIds)
{
var genre = context.Genres.Find(genreId);
if (genre == null)
{
throw new EntityNotFoundException("Zanr nije pronadjen");
}
}
if (context.Movies.Any(x => x.Title == request.Title))
{
throw new EntityAlreadyExist("Film vec postoji");
}
return(true);
}
public async Task <IActionResult> CreateMovie([FromBody] CreateMovieDTO movieDto)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (movieDto == null)
{
return(BadRequest(ModelState));
}
var movieObj = _mapper.Map <Movie>(movieDto);
var success = await _movieRepo.Create(movieObj);
if (!success)
{
ModelState.AddModelError("", "Something went wrong when creating record");
return(StatusCode(500, ModelState));
}
return(Created("Movie was created", new { movieObj }));
}
catch
{
return(StatusCode(500, "Something went wrong. please contact your admin"));
}
}
public async Task <ActionResult> Post([FromForm] CreateMovieDTO createMovieDTO)
{
var movie = _mapper.Map <Movie>(createMovieDTO);
if (createMovieDTO.Poster != null)
{
using (var memoryStream = new MemoryStream())
{
await createMovieDTO.Poster.CopyToAsync(memoryStream);
var content = memoryStream.ToArray();
var extension = Path.GetExtension(createMovieDTO.Poster.FileName);
movie.Poster = await _fileStorageService.SaveFile(content, extension, "movies", createMovieDTO.Poster.ContentType);
}
}
AnnotateActorsOrder(movie);
await _context.Movies.AddAsync(movie);
await _context.SaveChangesAsync();
var movieDTO = _mapper.Map <MovieDTO>(movie);
return(CreatedAtRoute("getMovie", new { id = movieDTO.Id }, movieDTO));
}
public async Task <ActionResult> Put(int id, [FromForm] CreateMovieDTO createMovieDTO)
{
var movieDBEntry = await _context.Movies.FirstOrDefaultAsync(x => x.Id == id);
if (movieDBEntry == null)
{
return(NotFound());
}
movieDBEntry = _mapper.Map(createMovieDTO, movieDBEntry);
if (createMovieDTO.Poster != null)
{
using (var memoryStream = new MemoryStream())
{
await createMovieDTO.Poster.CopyToAsync(memoryStream);
var content = memoryStream.ToArray();
var extension = Path.GetExtension(createMovieDTO.Poster.FileName);
movieDBEntry.Poster = await _fileStorageService.EditFile(content, extension, "movies", movieDBEntry.Poster, createMovieDTO.Poster.ContentType);
}
}
await _context.Database.ExecuteSqlInterpolatedAsync($"delete from MoviesActors where MovieId = {movieDBEntry.Id}; delete from MoviesGenres where MovieId = {movieDBEntry.Id}");
AnnotateActorsOrder(movieDBEntry);
await _context.SaveChangesAsync();
return(NoContent());
}
public bool CreateMovie(CreateMovieDTO createMovie)
{
Movie movie = new Movie
{
Title = createMovie.Title,
Category = Enum.Parse <Category>(createMovie.Category),
Description = createMovie.Description,
Duration = createMovie.Duration,
PosterUrl = createMovie.PosterUrl,
ScreeningTimes = new List <ScreeningTime>()
};
foreach (var screening in createMovie.ScreeningTimes)
{
ScreeningTime screeningTime = ScreeningTimeBuilder.Init(hallRepository)
.SetDate(screening.Date)
.SetSeatsFromHall(screening.HallId)
.Build();
movie.ScreeningTimes.Add(screeningTime);
}
movieRepository.Insert(movie);
return(movieRepository.SaveChanges() > 0);
}
public void ShouldUpdateMovie()
{
//Arrange
List <Row> rows = CreateRows();
Hall hall = CreateAndSaveHall(rows);
CreateAndSaveHall(rows);
CreateMovieDTO createMovieDto = CreateMovieDTODefault(hall.Id);
movieService.CreateMovie(createMovieDto);
UpdateMovieDTO updateMovieDTO = CreaUpdateMovieDTO();
//Act
movieService.UpdateMovie(updateMovieDTO);
//Assert
Movie updatedMovie = movieRepository.GetByID(1);
Assert.Single(movieRepository.GetAll());
Assert.Equal("UpdatedTitle", updatedMovie.Title);
Assert.Equal("UpdatedPoster", updatedMovie.PosterUrl);
Assert.Equal(100, updatedMovie.Duration);
Assert.Equal(Category.SciFi, updatedMovie.Category);
Assert.Equal("UpdatedDescription", updatedMovie.Description);
Assert.Equal(1, updatedMovie.Id);
Assert.Equal(2, updatedMovie.ScreeningTimes.Count);
}
public void Create(CreateMovieDTO model)
{
var dbModel = mapper.Map <Movie>(model);
service.Movie.Create(dbModel);
service.Commit();
}
public void Save(CreateMovieDTO model)
{
if (model != null)
{
var movie = _mapper.Map <CreateMovieCommand>(model);
_bus.SendCommand(movie);
}
}
public async Task <ActionResult <MoviesDTO> > AddMovie([FromForm] CreateMovieDTO createMovieDTO)
{
var movie = mapper.Map <Movie>(createMovieDTO);
await context.AddAsync(movie);
await context.SaveChangesAsync();
var movieDTO = mapper.Map <MoviesDTO>(movie);
return(new CreatedAtRouteResult("getMovieById", new { movieDTO.Id }, movieDTO));
}
private List <MoviesActors> MapMoviesActors(CreateMovieDTO createMovieDTO, Movie movie)
{
var result = new List <MoviesActors>();
foreach (var actor in createMovieDTO.Actors)
{
result.Add(new MoviesActors {
PersonId = actor.PersonId, CharacterName = actor.Character
});
}
return(result);
}
private List <MovieActors> MapMovieActors(CreateMovieDTO createMovieDTO, Movie movie)
{
var result = new List <MovieActors>();
foreach (ActorCreationDTO actor in createMovieDTO.Actors)
{
result.Add(new MovieActors()
{
PersonId = actor.PersonId, Order = actor.Order, Charactor = actor.Charactor
});
}
return(result);
}
private List <MovieGenres> MapMovieGenres(CreateMovieDTO createMovieDTO, Movie movie)
{
var result = new List <MovieGenres>();
foreach (int id in createMovieDTO.GenreIds)
{
result.Add(new MovieGenres()
{
GenreId = id
});
}
return(result);
}
public void ShouldCreateMovieAndCopySeats()
{
//Arrange
List <Row> rows = CreateRows();
Hall hall = CreateAndSaveHall(rows);
CreateMovieDTO createMovieDto = CreateMovieDTODefault(hall.Id);
//Act
movieService.CreateMovie(createMovieDto);
//Assert
Movie createdMovie = movieRepository.GetByID(1);
Assert.All(createdMovie.ScreeningTimes[0].Rows, r => rows.Any(x => x.RowIndex == r.RowIndex));
}
public IActionResult Post([FromForm] CreateMovieDTO dto)
{
try
{
createMovie.Execute(dto);
return(StatusCode(201));
}catch (EntityNotFoundException e)
{
return(UnprocessableEntity(e.Message));
}
catch (Exception ex)
{
return(StatusCode(500, ex.Message));
}
}
public void Execute(CreateMovieDTO request)
{
if (Validation(request))
{
var movie = new Movie
{
CreatedAt = DateTime.Now,
Title = request.Title,
StartShowingFrom = request.StartShowingFrom,
DurationMins = request.DurationMins,
Country = request.Country,
Year = request.Year,
PictureUrl = request.PictureUrl,
IsDeleted = false
};
foreach (var actorId in request.ActorsIds)
{
context.Movies_Actors.Add(new Movie_Actor
{
CreatedAt = DateTime.Now,
Movie = movie,
Actor = context.Actors.Find(actorId),
IsDeleted = false
});
}
foreach (var genreId in request.GenresIds)
{
context.Movies_Genres.Add(new Movie_Genre
{
CreatedAt = DateTime.Now,
Movie = movie,
Genre = context.Genres.Find(genreId),
IsDeleted = false
});
}
context.SaveChanges();
emailSender.Subject = "Uspesno ste kreirali film";
emailSender.Body = "Uspesno ste kreirali film";
emailSender.ToEmail = "*****@*****.**";
emailSender.Send();
}
}
public ActionResult Post([FromBody] CreateMovieDTO createMovieDTO)
{
try
{
_movieService.Save(createMovieDTO);
return(Ok());
}
catch (Exception e)
{
string errors = e.Message;
return(ValidationProblem(new ValidationProblemDetails()
{
Type = "Model Validation Error",
Detail = errors
}));
}
}
public async Task <ActionResult <MoviesDTO> > UpdateFromPut(int id, [FromForm] CreateMovieDTO createMovieDTO)
{
var movieDB = await context.Movies.FirstOrDefaultAsync(movie => movie.Id == id);
if (movieDB == null)
{
return(NoContent());
}
movieDB = mapper.Map(createMovieDTO, movieDB);
movieDB.Id = id;
await context.Database.ExecuteSqlInterpolatedAsync($"delete from MovieActors where MovieId={id};delete from MovieGenres where MovieId={id}");
await context.SaveChangesAsync();
var updatedDetails = mapper.Map <MoviesDTO>(movieDB);
return(updatedDetails);
}
public ActionResult Create(CreateMovieDTO request)
{
if (!ModelState.IsValid)
{
TempData["greska"] = "Greska pri unosu";
RedirectToAction("create");
}
try
{
createMovie.Execute(request);
return(RedirectToAction(nameof(Index)));
}
catch (EntityAlreadyExist e)
{
TempData["error"] = e.Message;
}
catch (Exception e)
{
TempData["error"] = e.Message;
}
return(View());
}
public ActionResult <bool> CreateMovie(CreateMovieDTO createMovie)
{
return(Created("", movieService.CreateMovie(createMovie)));
}
